Apply updated GT5u spotless configs

3 files changed, 615 insertions, 606 deletions

diff --git a/src/main/java/gtPlusPlus/xmod/gregtech/common/render/GTPP_CapeRenderer.java b/src/main/java/gtPlusPlus/xmod/gregtech/common/render/GTPP_CapeRenderer.java
index 1e097f910b..a281a205d2 100644
--- a/src/main/java/gtPlusPlus/xmod/gregtech/common/render/GTPP_CapeRenderer.java
+++ b/src/main/java/gtPlusPlus/xmod/gregtech/common/render/GTPP_CapeRenderer.java
@@ -35,10 +35,10 @@ import gtPlusPlus.core.util.math.MathUtils;
 public class GTPP_CapeRenderer extends RenderPlayer {
 
     private static final ResourceLocation[] mCapes = { new ResourceLocation("miscutils:textures/OrangeHD.png"),
-            new ResourceLocation("miscutils:textures/FancyCapeHD.png"),
-            new ResourceLocation("miscutils:textures/TesterCapeHD.png"),
-            new ResourceLocation("miscutils:textures/PatreonCapeHD.png"),
-            new ResourceLocation("miscutils:textures/DevCapeHD.png"), };
+        new ResourceLocation("miscutils:textures/FancyCapeHD.png"),
+        new ResourceLocation("miscutils:textures/TesterCapeHD.png"),
+        new ResourceLocation("miscutils:textures/PatreonCapeHD.png"),
+        new ResourceLocation("miscutils:textures/DevCapeHD.png"), };
 
     private final boolean mInit;
 
@@ -103,7 +103,9 @@ public class GTPP_CapeRenderer extends RenderPlayer {
             if (!hasResourceChecked) {
 
                 // Get players UUID
-                String aPlayerUUID = aPlayer != null ? aPlayer.getGameProfile().getId().toString() : "BAD";
+                String aPlayerUUID = aPlayer != null ? aPlayer.getGameProfile()
+                    .getId()
+                    .toString() : "BAD";
 
                 // If for whatever reason this fails, we just exit early.
                 if (aPlayerUUID.equals("BAD")) {
@@ -121,7 +123,8 @@ public class GTPP_CapeRenderer extends RenderPlayer {
                 // Check cape lists for the cape this player owns.
                 if (!hasCape) {
                     for (Pair<String, String> aData : CapeUtils.mOrangeCapes) {
-                        if (aData.getKey().equals(aPlayerUUID) || aPlayerName.equals(aData.getValue())) {
+                        if (aData.getKey()
+                            .equals(aPlayerUUID) || aPlayerName.equals(aData.getValue())) {
                             tResource = mCapes[0];
                             hasCape = true;
                             break;
@@ -130,7 +133,8 @@ public class GTPP_CapeRenderer extends RenderPlayer {
                 }
                 if (!hasCape) {
                     for (Pair<String, String> aData : CapeUtils.mMiscCapes) {
-                        if (aData.getKey().equals(aPlayerUUID) || aPlayerName.equals(aData.getValue())) {
+                        if (aData.getKey()
+                            .equals(aPlayerUUID) || aPlayerName.equals(aData.getValue())) {
                             tResource = mCapes[1];
                             hasCape = true;
                             break;
@@ -139,7 +143,8 @@ public class GTPP_CapeRenderer extends RenderPlayer {
                 }
                 if (!hasCape) {
                     for (Pair<String, String> aData : CapeUtils.mBetaTestCapes) {
-                        if (aData.getKey().equals(aPlayerUUID) || aPlayerName.equals(aData.getValue())) {
+                        if (aData.getKey()
+                            .equals(aPlayerUUID) || aPlayerName.equals(aData.getValue())) {
                             tResource = mCapes[2];
                             hasCape = true;
                             break;
@@ -148,7 +153,8 @@ public class GTPP_CapeRenderer extends RenderPlayer {
                 }
                 if (!hasCape) {
                     for (Pair<String, String> aData : CapeUtils.mPatreonCapes) {
-                        if (aData.getKey().equals(aPlayerUUID) || aPlayerName.equals(aData.getValue())) {
+                        if (aData.getKey()
+                            .equals(aPlayerUUID) || aPlayerName.equals(aData.getValue())) {
                             tResource = mCapes[3];
                             hasCape = true;
                             break;
@@ -157,7 +163,8 @@ public class GTPP_CapeRenderer extends RenderPlayer {
                 }
                 if (!hasCape) {
                     for (Pair<String, String> aData : CapeUtils.mDevCapes) {
-                        if (aData.getKey().equals(aPlayerUUID) || aPlayerName.equals(aData.getValue())) {
+                        if (aData.getKey()
+                            .equals(aPlayerUUID) || aPlayerName.equals(aData.getValue())) {
                             tResource = mCapes[4];
                             hasCape = true;
                             break;
@@ -183,7 +190,7 @@ public class GTPP_CapeRenderer extends RenderPlayer {
 
             // If player is invisible, don't render.
             if (GT_Utility.getFullInvisibility(aPlayer) || aPlayer.isInvisible()
-                    || GT_Utility.getPotion(aPlayer, Integer.valueOf(Potion.invisibility.id))) {
+                || GT_Utility.getPotion(aPlayer, Integer.valueOf(Potion.invisibility.id))) {
                 aEvent.setCanceled(true);
                 return false;
             }
@@ -193,13 +200,13 @@ public class GTPP_CapeRenderer extends RenderPlayer {
                 GL11.glPushMatrix();
                 GL11.glTranslatef(0.0F, 0.0F, 0.125F);
                 double d0 = aPlayer.field_71091_bM + (aPlayer.field_71094_bP - aPlayer.field_71091_bM) * aPartialTicks
-                        - (aPlayer.prevPosX + (aPlayer.posX - aPlayer.prevPosX) * aPartialTicks);
+                    - (aPlayer.prevPosX + (aPlayer.posX - aPlayer.prevPosX) * aPartialTicks);
                 double d1 = aPlayer.field_71096_bN + (aPlayer.field_71095_bQ - aPlayer.field_71096_bN) * aPartialTicks
-                        - (aPlayer.prevPosY + (aPlayer.posY - aPlayer.prevPosY) * aPartialTicks);
+                    - (aPlayer.prevPosY + (aPlayer.posY - aPlayer.prevPosY) * aPartialTicks);
                 double d2 = aPlayer.field_71097_bO + (aPlayer.field_71085_bR - aPlayer.field_71097_bO) * aPartialTicks
-                        - (aPlayer.prevPosZ + (aPlayer.posZ - aPlayer.prevPosZ) * aPartialTicks);
+                    - (aPlayer.prevPosZ + (aPlayer.posZ - aPlayer.prevPosZ) * aPartialTicks);
                 float f6 = aPlayer.prevRenderYawOffset
-                        + (aPlayer.renderYawOffset - aPlayer.prevRenderYawOffset) * aPartialTicks;
+                    + (aPlayer.renderYawOffset - aPlayer.prevRenderYawOffset) * aPartialTicks;
                 double d3 = MathHelper.sin(f6 * CORE.PI / 180.0F);
                 double d4 = -MathHelper.cos(f6 * CORE.PI / 180.0F);
                 float f7 = (float) d1 * 10.0F;
@@ -216,11 +223,10 @@ public class GTPP_CapeRenderer extends RenderPlayer {
                 }
                 float f10 = aPlayer.prevCameraYaw + (aPlayer.cameraYaw - aPlayer.prevCameraYaw) * aPartialTicks;
                 f7 += MathHelper.sin(
-                        (aPlayer.prevDistanceWalkedModified
-                                + (aPlayer.distanceWalkedModified - aPlayer.prevDistanceWalkedModified) * aPartialTicks)
-                                * 6.0F)
-                        * 32.0F
-                        * f10;
+                    (aPlayer.prevDistanceWalkedModified
+                        + (aPlayer.distanceWalkedModified - aPlayer.prevDistanceWalkedModified) * aPartialTicks) * 6.0F)
+                    * 32.0F
+                    * f10;
                 if (aPlayer.isSneaking()) {
                     f7 += 25.0F;
                 }
@@ -257,14 +263,15 @@ public class GTPP_CapeRenderer extends RenderPlayer {
             if (CORE.DEVENV) {
                 return true;
             }
-            ForkJoinPool.commonPool().execute(() -> {
-                try {
-                    if (shouldDownloadCapeList()) {
-                        downloadCapeList();
-                    }
-                } catch (Exception ignored) {}
-                cacheReady = true;
-            });
+            ForkJoinPool.commonPool()
+                .execute(() -> {
+                    try {
+                        if (shouldDownloadCapeList()) {
+                            downloadCapeList();
+                        }
+                    } catch (Exception ignored) {}
+                    cacheReady = true;
+                });
             return true;
         }
 
@@ -358,7 +365,7 @@ public class GTPP_CapeRenderer extends RenderPlayer {
             }
             if (tempFile == null) {
                 tempFile = FileUtils
-                        .createFile("", "gtpp-" + MathUtils.randInt(Short.MAX_VALUE, (Integer.MAX_VALUE / 2)), "tmp");
+                    .createFile("", "gtpp-" + MathUtils.randInt(Short.MAX_VALUE, (Integer.MAX_VALUE / 2)), "tmp");
             }
             tempFile.deleteOnExit();
             return tempFile;
@@ -390,51 +397,51 @@ public class GTPP_CapeRenderer extends RenderPlayer {
                                 if (aCapeTypeID2 != null) {
                                     int aCapeTypeID = aCapeTypeID2;
                                     Pair<String, String> aFinalString = new Pair<>(
-                                            "UUID: " + aSplitData[1],
-                                            "Username: " + (aSplitData[2] != null && aSplitData[0].length() > 0
-                                                    ? aSplitData[2]
-                                                    : "Not Specified"));
+                                        "UUID: " + aSplitData[1],
+                                        "Username: "
+                                            + (aSplitData[2] != null && aSplitData[0].length() > 0 ? aSplitData[2]
+                                                : "Not Specified"));
                                     Logger.INFO("Cape Type: " + aCapeTypeID);
                                     switch (aCapeTypeID) {
                                         case 0 -> {
                                             aCapeType1.add(aFinalString);
                                             Logger.INFO(
-                                                    "Added user to map " + aCapeTypeID
-                                                            + ", map now holds "
-                                                            + aCapeType1.size()
-                                                            + " users.");
+                                                "Added user to map " + aCapeTypeID
+                                                    + ", map now holds "
+                                                    + aCapeType1.size()
+                                                    + " users.");
                                         }
                                         case 1 -> {
                                             aCapeType2.add(aFinalString);
                                             Logger.INFO(
-                                                    "Added user to map " + aCapeTypeID
-                                                            + ", map now holds "
-                                                            + aCapeType2.size()
-                                                            + " users.");
+                                                "Added user to map " + aCapeTypeID
+                                                    + ", map now holds "
+                                                    + aCapeType2.size()
+                                                    + " users.");
                                         }
                                         case 2 -> {
                                             aCapeType3.add(aFinalString);
                                             Logger.INFO(
-                                                    "Added user to map " + aCapeTypeID
-                                                            + ", map now holds "
-                                                            + aCapeType3.size()
-                                                            + " users.");
+                                                "Added user to map " + aCapeTypeID
+                                                    + ", map now holds "
+                                                    + aCapeType3.size()
+                                                    + " users.");
                                         }
                                         case 3 -> {
                                             aCapeType4.add(aFinalString);
                                             Logger.INFO(
-                                                    "Added user to map " + aCapeTypeID
-                                                            + ", map now holds "
-                                                            + aCapeType4.size()
-                                                            + " users.");
+                                                "Added user to map " + aCapeTypeID
+                                                    + ", map now holds "
+                                                    + aCapeType4.size()
+                                                    + " users.");
                                         }
                                         case 4 -> {
                                             aCapeType5.add(aFinalString);
                                             Logger.INFO(
-                                                    "Added user to map " + aCapeTypeID
-                                                            + ", map now holds "
-                                                            + aCapeType5.size()
-                                                            + " users.");
+                                                "Added user to map " + aCapeTypeID
+                                                    + ", map now holds "
+                                                    + aCapeType5.size()
+                                                    + " users.");
                                         }
                                         default -> {}
                                     }
@@ -443,9 +450,9 @@ public class GTPP_CapeRenderer extends RenderPlayer {
                         }
                     }
                     if (!aCapeType1.isEmpty() || !aCapeType2.isEmpty()
-                            || !aCapeType3.isEmpty()
-                            || !aCapeType4.isEmpty()
-                            || !aCapeType5.isEmpty()) {
+                        || !aCapeType3.isEmpty()
+                        || !aCapeType4.isEmpty()
+                        || !aCapeType5.isEmpty()) {
                         didProcessStringData = true;
                     } else {
                         // did not process any data
diff --git a/src/main/java/gtPlusPlus/xmod/gregtech/common/render/GTPP_FlaskRenderer.java b/src/main/java/gtPlusPlus/xmod/gregtech/common/render/GTPP_FlaskRenderer.java
index 93e139ef66..0c9e59e2f2 100644
--- a/src/main/java/gtPlusPlus/xmod/gregtech/common/render/GTPP_FlaskRenderer.java
+++ b/src/main/java/gtPlusPlus/xmod/gregtech/common/render/GTPP_FlaskRenderer.java
@@ -58,8 +58,10 @@ public final class GTPP_FlaskRenderer implements net.minecraftforge.client.IItem
         FluidStack fs = cell.getFluid(item);
         if (fs != null) {
             IIcon iconWindow = cell.iconWindow;
-            IIcon fluidicon = fs.getFluid().getIcon(fs);
-            int fluidColor = fs.getFluid().getColor(fs);
+            IIcon fluidicon = fs.getFluid()
+                .getIcon(fs);
+            int fluidColor = fs.getFluid()
+                .getColor(fs);
             Minecraft.getMinecraft().renderEngine.bindTexture(TextureMap.locationItemsTexture);
             GL11.glBlendFunc(0, 1);
             if (type.equals(ItemRenderType.INVENTORY)) {
@@ -90,14 +92,14 @@ public final class GTPP_FlaskRenderer implements net.minecraftforge.client.IItem
             DrawUtil.renderIcon(icon, 16.0D, 0.001D, 0.0F, 0.0F, -1.0F);
         } else {
             ItemRenderer.renderItemIn2D(
-                    Tessellator.instance,
-                    icon.getMaxU(),
-                    icon.getMinV(),
-                    icon.getMinU(),
-                    icon.getMaxV(),
-                    icon.getIconWidth(),
-                    icon.getIconHeight(),
-                    0.0625F);
+                Tessellator.instance,
+                icon.getMaxU(),
+                icon.getMinV(),
+                icon.getMinU(),
+                icon.getMaxV(),
+                icon.getIconWidth(),
+                icon.getIconHeight(),
+                0.0625F);
         }
         GL11.glDisable(3008);
         GL11.glDisable(3042);
diff --git a/src/main/java/gtPlusPlus/xmod/gregtech/common/render/GTPP_Render_MachineBlock.java b/src/main/java/gtPlusPlus/xmod/gregtech/common/render/GTPP_Render_MachineBlock.java
index 4c51b1ff09..bfd16b4cc5 100644
--- a/src/main/java/gtPlusPlus/xmod/gregtech/common/render/GTPP_Render_MachineBlock.java
+++ b/src/main/java/gtPlusPlus/xmod/gregtech/common/render/GTPP_Render_MachineBlock.java
@@ -50,13 +50,13 @@ public class GTPP_Render_MachineBlock extends GT_Renderer_Block {
     }
 
     private static ITexture[] getTexture(IMetaTileEntity tile, ForgeDirection side, ForgeDirection facing,
-            int colorIndex, boolean active, boolean arg5) {
+        int colorIndex, boolean active, boolean arg5) {
         final IGregTechTileEntity gtTile = tile.getBaseMetaTileEntity();
         return tile.getTexture(gtTile, side, facing, (byte) colorIndex, active, arg5);
     }
 
     private static ITexture[] getTexture(IMetaTileEntity tile, ForgeDirection side, int facingMask, int colorIndex,
-            boolean active, boolean arg5) {
+        boolean active, boolean arg5) {
         final MetaPipeEntity gtTile = (MetaPipeEntity) tile.getBaseMetaTileEntity();
         return gtTile.getTexture((IGregTechTileEntity) tile, side, facingMask, colorIndex, active, arg5);
     }
@@ -77,147 +77,147 @@ public class GTPP_Render_MachineBlock extends GT_Renderer_Block {
                     Tessellator.instance.startDrawingQuads();
                     Tessellator.instance.setNormal(0.0F, -1.0F, 0.0F);
                     renderNegativeYFacing(
-                            null,
-                            aRenderer,
-                            aBlock,
-                            0,
-                            0,
-                            0,
-                            getTexture(tMetaTileEntity, DOWN, 0b001001, -1, false, false),
-                            true);
+                        null,
+                        aRenderer,
+                        aBlock,
+                        0,
+                        0,
+                        0,
+                        getTexture(tMetaTileEntity, DOWN, 0b001001, -1, false, false),
+                        true);
                     Tessellator.instance.draw();
                     Tessellator.instance.startDrawingQuads();
                     Tessellator.instance.setNormal(0.0F, 1.0F, 0.0F);
                     renderPositiveYFacing(
-                            null,
-                            aRenderer,
-                            aBlock,
-                            0,
-                            0,
-                            0,
-                            getTexture(tMetaTileEntity, UP, 0b001001, -1, false, false),
-                            true);
+                        null,
+                        aRenderer,
+                        aBlock,
+                        0,
+                        0,
+                        0,
+                        getTexture(tMetaTileEntity, UP, 0b001001, -1, false, false),
+                        true);
                     Tessellator.instance.draw();
                     Tessellator.instance.startDrawingQuads();
                     Tessellator.instance.setNormal(0.0F, 0.0F, -1.0F);
                     renderNegativeZFacing(
-                            null,
-                            aRenderer,
-                            aBlock,
-                            0,
-                            0,
-                            0,
-                            getTexture(tMetaTileEntity, ForgeDirection.NORTH, 0b001001, -1, false, false),
-                            true);
+                        null,
+                        aRenderer,
+                        aBlock,
+                        0,
+                        0,
+                        0,
+                        getTexture(tMetaTileEntity, ForgeDirection.NORTH, 0b001001, -1, false, false),
+                        true);
                     Tessellator.instance.draw();
                     Tessellator.instance.startDrawingQuads();
                     Tessellator.instance.setNormal(0.0F, 0.0F, 1.0F);
                     renderPositiveZFacing(
-                            null,
-                            aRenderer,
-                            aBlock,
-                            0,
-                            0,
-                            0,
-                            getTexture(tMetaTileEntity, ForgeDirection.SOUTH, 0b001001, -1, false, false),
-                            true);
+                        null,
+                        aRenderer,
+                        aBlock,
+                        0,
+                        0,
+                        0,
+                        getTexture(tMetaTileEntity, ForgeDirection.SOUTH, 0b001001, -1, false, false),
+                        true);
                     Tessellator.instance.draw();
                     Tessellator.instance.startDrawingQuads();
                     Tessellator.instance.setNormal(-1.0F, 0.0F, 0.0F);
                     renderNegativeXFacing(
-                            null,
-                            aRenderer,
-                            aBlock,
-                            0,
-                            0,
-                            0,
-                            getTexture(tMetaTileEntity, ForgeDirection.WEST, 0b001001, -1, true, false),
-                            true);
+                        null,
+                        aRenderer,
+                        aBlock,
+                        0,
+                        0,
+                        0,
+                        getTexture(tMetaTileEntity, ForgeDirection.WEST, 0b001001, -1, true, false),
+                        true);
                     Tessellator.instance.draw();
                     Tessellator.instance.startDrawingQuads();
                     Tessellator.instance.setNormal(1.0F, 0.0F, 0.0F);
                     renderPositiveXFacing(
-                            null,
-                            aRenderer,
-                            aBlock,
-                            0,
-                            0,
-                            0,
-                            getTexture(tMetaTileEntity, ForgeDirection.EAST, 0b001001, -1, true, false),
-                            true);
+                        null,
+                        aRenderer,
+                        aBlock,
+                        0,
+                        0,
+                        0,
+                        getTexture(tMetaTileEntity, ForgeDirection.EAST, 0b001001, -1, true, false),
+                        true);
                     Tessellator.instance.draw();
                 } else {
                     Tessellator.instance.startDrawingQuads();
                     Tessellator.instance.setNormal(0.0F, -1.0F, 0.0F);
                     renderNegativeYFacing(
-                            null,
-                            aRenderer,
-                            aBlock,
-                            0,
-                            0,
-                            0,
-                            getTexture(tMetaTileEntity, DOWN, ForgeDirection.WEST, -1, true, false),
-                            true);
+                        null,
+                        aRenderer,
+                        aBlock,
+                        0,
+                        0,
+                        0,
+                        getTexture(tMetaTileEntity, DOWN, ForgeDirection.WEST, -1, true, false),
+                        true);
                     Tessellator.instance.draw();
                     Tessellator.instance.startDrawingQuads();
                     Tessellator.instance.setNormal(0.0F, 1.0F, 0.0F);
                     renderPositiveYFacing(
-                            null,
-                            aRenderer,
-                            aBlock,
-                            0,
-                            0,
-                            0,
-                            getTexture(tMetaTileEntity, UP, ForgeDirection.WEST, -1, true, false),
-                            true);
+                        null,
+                        aRenderer,
+                        aBlock,
+                        0,
+                        0,
+                        0,
+                        getTexture(tMetaTileEntity, UP, ForgeDirection.WEST, -1, true, false),
+                        true);
                     Tessellator.instance.draw();
                     Tessellator.instance.startDrawingQuads();
                     Tessellator.instance.setNormal(0.0F, 0.0F, -1.0F);
                     renderNegativeZFacing(
-                            null,
-                            aRenderer,
-                            aBlock,
-                            0,
-                            0,
-                            0,
-                            getTexture(tMetaTileEntity, ForgeDirection.NORTH, ForgeDirection.WEST, -1, true, false),
-                            true);
+                        null,
+                        aRenderer,
+                        aBlock,
+                        0,
+                        0,
+                        0,
+                        getTexture(tMetaTileEntity, ForgeDirection.NORTH, ForgeDirection.WEST, -1, true, false),
+                        true);
                     Tessellator.instance.draw();
                     Tessellator.instance.startDrawingQuads();
                     Tessellator.instance.setNormal(0.0F, 0.0F, 1.0F);
                     renderPositiveZFacing(
-                            null,
-                            aRenderer,
-                            aBlock,
-                            0,
-                            0,
-                            0,
-                            getTexture(tMetaTileEntity, ForgeDirection.SOUTH, ForgeDirection.WEST, -1, true, false),
-                            true);
+                        null,
+                        aRenderer,
+                        aBlock,
+                        0,
+                        0,
+                        0,
+                        getTexture(tMetaTileEntity, ForgeDirection.SOUTH, ForgeDirection.WEST, -1, true, false),
+                        true);
                     Tessellator.instance.draw();
                     Tessellator.instance.startDrawingQuads();
                     Tessellator.instance.setNormal(-1.0F, 0.0F, 0.0F);
                     renderNegativeXFacing(
-                            null,
-                            aRenderer,
-                            aBlock,
-                            0,
-                            0,
-                            0,
-                            getTexture(tMetaTileEntity, ForgeDirection.WEST, ForgeDirection.WEST, -1, true, false),
-                            true);
+                        null,
+                        aRenderer,
+                        aBlock,
+                        0,
+                        0,
+                        0,
+                        getTexture(tMetaTileEntity, ForgeDirection.WEST, ForgeDirection.WEST, -1, true, false),
+                        true);
                     Tessellator.instance.draw();
                     Tessellator.instance.startDrawingQuads();
                     Tessellator.instance.setNormal(1.0F, 0.0F, 0.0F);
                     renderPositiveXFacing(
-                            null,
-                            aRenderer,
-                            aBlock,
-                            0,
-                            0,
-                            0,
-                            getTexture(tMetaTileEntity, ForgeDirection.EAST, ForgeDirection.WEST, -1, true, false),
-                            true);
+                        null,
+                        aRenderer,
+                        aBlock,
+                        0,
+                        0,
+                        0,
+                        getTexture(tMetaTileEntity, ForgeDirection.EAST, ForgeDirection.WEST, -1, true, false),
+                        true);
                     Tessellator.instance.draw();
                 }
 
@@ -229,28 +229,28 @@ public class GTPP_Render_MachineBlock extends GT_Renderer_Block {
     }
 
     public boolean renderStandardBlock(IBlockAccess aWorld, int aX, int aY, int aZ, Block aBlock,
-            RenderBlocks aRenderer) {
+        RenderBlocks aRenderer) {
         TileEntity tTileEntity = aWorld.getTileEntity(aX, aY, aZ);
 
         return tTileEntity instanceof ITexturedTileEntity
-                ? renderStandardBlock(
-                        aWorld,
-                        aX,
-                        aY,
-                        aZ,
-                        aBlock,
-                        aRenderer,
-                        new ITexture[][] { GT_MethodHelper.getTexture(tTileEntity, aBlock, DOWN),
-                                GT_MethodHelper.getTexture(tTileEntity, aBlock, UP),
-                                GT_MethodHelper.getTexture(tTileEntity, aBlock, ForgeDirection.NORTH),
-                                GT_MethodHelper.getTexture(tTileEntity, aBlock, ForgeDirection.SOUTH),
-                                GT_MethodHelper.getTexture(tTileEntity, aBlock, ForgeDirection.WEST),
-                                GT_MethodHelper.getTexture(tTileEntity, aBlock, ForgeDirection.EAST) })
-                : false;
+            ? renderStandardBlock(
+                aWorld,
+                aX,
+                aY,
+                aZ,
+                aBlock,
+                aRenderer,
+                new ITexture[][] { GT_MethodHelper.getTexture(tTileEntity, aBlock, DOWN),
+                    GT_MethodHelper.getTexture(tTileEntity, aBlock, UP),
+                    GT_MethodHelper.getTexture(tTileEntity, aBlock, ForgeDirection.NORTH),
+                    GT_MethodHelper.getTexture(tTileEntity, aBlock, ForgeDirection.SOUTH),
+                    GT_MethodHelper.getTexture(tTileEntity, aBlock, ForgeDirection.WEST),
+                    GT_MethodHelper.getTexture(tTileEntity, aBlock, ForgeDirection.EAST) })
+            : false;
     }
 
     public boolean renderStandardBlock(IBlockAccess aWorld, int aX, int aY, int aZ, Block aBlock,
-            RenderBlocks aRenderer, ITexture[][] aTextures) {
+        RenderBlocks aRenderer, ITexture[][] aTextures) {
         aBlock.setBlockBounds(0.0F, 0.0F, 0.0F, 1.0F, 1.0F, 1.0F);
         aRenderer.setRenderBoundsFromBlock(aBlock);
         renderNegativeYFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, aTextures[DOWN.ordinal()], true);
@@ -263,7 +263,7 @@ public class GTPP_Render_MachineBlock extends GT_Renderer_Block {
     }
 
     public boolean renderPipeBlock(IBlockAccess aWorld, int aX, int aY, int aZ, Block aBlock,
-            IPipeRenderedTileEntity aTileEntity, RenderBlocks aRenderer) {
+        IPipeRenderedTileEntity aTileEntity, RenderBlocks aRenderer) {
         final int aConnections = aTileEntity.getConnections();
         if ((aConnections & HAS_FOAM) != 0) {
             return renderStandardBlock(aWorld, aX, aY, aZ, aBlock, aRenderer);
@@ -303,64 +303,263 @@ public class GTPP_Render_MachineBlock extends GT_Renderer_Block {
                             aBlock.setBlockBounds(sp, sp, sp, sp + tThickness, sp + tThickness, sp + tThickness);
                             aRenderer.setRenderBoundsFromBlock(aBlock);
                             renderNegativeYFacing(
+                                aWorld,
+                                aRenderer,
+                                aBlock,
+                                aX,
+                                aY,
+                                aZ,
+                                textureUncovered.get(DOWN),
+                                false);
+                            renderPositiveYFacing(
+                                aWorld,
+                                aRenderer,
+                                aBlock,
+                                aX,
+                                aY,
+                                aZ,
+                                textureUncovered.get(UP),
+                                false);
+                            renderNegativeZFacing(
+                                aWorld,
+                                aRenderer,
+                                aBlock,
+                                aX,
+                                aY,
+                                aZ,
+                                textureUncovered.get(NORTH),
+                                false);
+                            renderPositiveZFacing(
+                                aWorld,
+                                aRenderer,
+                                aBlock,
+                                aX,
+                                aY,
+                                aZ,
+                                textureUncovered.get(SOUTH),
+                                false);
+                            renderNegativeXFacing(
+                                aWorld,
+                                aRenderer,
+                                aBlock,
+                                aX,
+                                aY,
+                                aZ,
+                                textureUncovered.get(WEST),
+                                false);
+                            renderPositiveXFacing(
+                                aWorld,
+                                aRenderer,
+                                aBlock,
+                                aX,
+                                aY,
+                                aZ,
+                                textureUncovered.get(EAST),
+                                false);
+                        }
+                        case (CONNECTED_DOWN | CONNECTED_UP) -> {
+                            aBlock.setBlockBounds(0.0F, sp, sp, 1.0F, sp + tThickness, sp + tThickness);
+                            aRenderer.setRenderBoundsFromBlock(aBlock);
+                            renderNegativeYFacing(
+                                aWorld,
+                                aRenderer,
+                                aBlock,
+                                aX,
+                                aY,
+                                aZ,
+                                textureUncovered.get(DOWN),
+                                false);
+                            renderPositiveYFacing(
+                                aWorld,
+                                aRenderer,
+                                aBlock,
+                                aX,
+                                aY,
+                                aZ,
+                                textureUncovered.get(UP),
+                                false);
+                            renderNegativeZFacing(
+                                aWorld,
+                                aRenderer,
+                                aBlock,
+                                aX,
+                                aY,
+                                aZ,
+                                textureUncovered.get(NORTH),
+                                false);
+                            renderPositiveZFacing(
+                                aWorld,
+                                aRenderer,
+                                aBlock,
+                                aX,
+                                aY,
+                                aZ,
+                                textureUncovered.get(SOUTH),
+                                false);
+                            if (!coveredSides.contains(WEST)) {
+                                renderNegativeXFacing(
                                     aWorld,
                                     aRenderer,
                                     aBlock,
                                     aX,
                                     aY,
                                     aZ,
-                                    textureUncovered.get(DOWN),
+                                    textureUncovered.get(WEST),
                                     false);
-                            renderPositiveYFacing(
+                            }
+                            if (!coveredSides.contains(EAST)) {
+                                renderPositiveXFacing(
                                     aWorld,
                                     aRenderer,
                                     aBlock,
                                     aX,
                                     aY,
                                     aZ,
-                                    textureUncovered.get(UP),
+                                    textureUncovered.get(EAST),
                                     false);
+                            }
+                        }
+                        case (CONNECTED_NORTH | CONNECTED_SOUTH) -> {
+                            aBlock.setBlockBounds(sp, 0.0F, sp, sp + tThickness, 1.0F, sp + tThickness);
+                            aRenderer.setRenderBoundsFromBlock(aBlock);
                             renderNegativeZFacing(
+                                aWorld,
+                                aRenderer,
+                                aBlock,
+                                aX,
+                                aY,
+                                aZ,
+                                textureUncovered.get(NORTH),
+                                false);
+                            renderPositiveZFacing(
+                                aWorld,
+                                aRenderer,
+