Update buildscript & apply spotless (#1306)

* Update dependencies

* Update buildscript, apply spotless

8 files changed, 741 insertions, 372 deletions

diff --git a/src/main/java/gregtech/common/tileentities/generators/GT_MetaTileEntity_DieselGenerator.java b/src/main/java/gregtech/common/tileentities/generators/GT_MetaTileEntity_DieselGenerator.java
index 6a712b41f5..ca6e77225e 100644
--- a/src/main/java/gregtech/common/tileentities/generators/GT_MetaTileEntity_DieselGenerator.java
+++ b/src/main/java/gregtech/common/tileentities/generators/GT_MetaTileEntity_DieselGenerator.java
@@ -1,13 +1,16 @@
 package gregtech.common.tileentities.generators;
 
+import static gregtech.api.enums.Textures.BlockIcons.*;
+import static gregtech.api.objects.XSTR.XSTR_INSTANCE;
+
 import cpw.mods.fml.common.registry.GameRegistry;
 import cpw.mods.fml.relauncher.Side;
 import cpw.mods.fml.relauncher.SideOnly;
 import gregtech.GT_Mod;
 import gregtech.api.GregTech_API;
-import gregtech.api.enums.ParticleFX;
 import gregtech.api.enums.ConfigCategories;
 import gregtech.api.enums.ItemList;
+import gregtech.api.enums.ParticleFX;
 import gregtech.api.interfaces.ITexture;
 import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
 import gregtech.api.metatileentity.MetaTileEntity;
@@ -22,19 +25,18 @@ import net.minecraft.block.Block;
 import net.minecraft.item.ItemStack;
 import net.minecraftforge.common.util.ForgeDirection;
 
-import static gregtech.api.enums.Textures.BlockIcons.*;
-import static gregtech.api.objects.XSTR.XSTR_INSTANCE;
-
 public class GT_MetaTileEntity_DieselGenerator extends GT_MetaTileEntity_BasicGenerator {
 
-
-
     public int mEfficiency;
 
     public GT_MetaTileEntity_DieselGenerator(int aID, String aName, String aNameRegional, int aTier) {
-        super(aID, aName, aNameRegional, aTier, new String[]{
-                "Requires liquid Fuel",
-                "Causes " + (int) (GT_Mod.gregtechproxy.mPollutionBaseDieselGeneratorPerSecond * GT_Mod.gregtechproxy.mPollutionDieselGeneratorReleasedByTier[aTier]) + " Pollution per second"});
+        super(aID, aName, aNameRegional, aTier, new String[] {
+            "Requires liquid Fuel",
+            "Causes "
+                    + (int) (GT_Mod.gregtechproxy.mPollutionBaseDieselGeneratorPerSecond
+                            * GT_Mod.gregtechproxy.mPollutionDieselGeneratorReleasedByTier[aTier])
+                    + " Pollution per second"
+        });
         onConfigLoad();
     }
 
@@ -69,7 +71,10 @@ public class GT_MetaTileEntity_DieselGenerator extends GT_MetaTileEntity_BasicGe
     }
 
     public void onConfigLoad() {
-        this.mEfficiency = GregTech_API.sMachineFile.get(ConfigCategories.machineconfig, "DieselGenerator.efficiency.tier." + this.mTier, (100 - this.mTier * 5));
+        this.mEfficiency = GregTech_API.sMachineFile.get(
+                ConfigCategories.machineconfig,
+                "DieselGenerator.efficiency.tier." + this.mTier,
+                (100 - this.mTier * 5));
     }
 
     @Override
@@ -93,7 +98,9 @@ public class GT_MetaTileEntity_DieselGenerator extends GT_MetaTileEntity_BasicGe
     @Override
     public void onPostTick(IGregTechTileEntity aBaseMetaTileEntity, long aTick) {
         if (aTick % 100 == 0 && mFluid != null && mFluid.amount > this.getCapacity()) {
-            GT_Log.err.println("Dupe Abuse: " + aBaseMetaTileEntity.getOwnerName() + " Coords: " + aBaseMetaTileEntity.getXCoord() + " " + aBaseMetaTileEntity.getYCoord() + " " + aBaseMetaTileEntity.getZCoord());
+            GT_Log.err.println(
+                    "Dupe Abuse: " + aBaseMetaTileEntity.getOwnerName() + " Coords: " + aBaseMetaTileEntity.getXCoord()
+                            + " " + aBaseMetaTileEntity.getYCoord() + " " + aBaseMetaTileEntity.getZCoord());
             aBaseMetaTileEntity.setToFire();
         }
         super.onPostTick(aBaseMetaTileEntity, aTick);
@@ -112,97 +119,159 @@ public class GT_MetaTileEntity_DieselGenerator extends GT_MetaTileEntity_BasicGe
             final byte topFacing = (byte) ForgeDirection.UP.ordinal();
 
             if (aBaseMetaTileEntity.getCoverIDAtSide(topFacing) == 0
-                && !aBaseMetaTileEntity.getOpacityAtSide(topFacing)) {
+                    && !aBaseMetaTileEntity.getOpacityAtSide(topFacing)) {
 
-                final double x = aBaseMetaTileEntity.getOffsetX(topFacing, 1) + 2D / 16D
-                    + XSTR_INSTANCE.nextFloat() * 14D / 16D;
+                final double x =
+                        aBaseMetaTileEntity.getOffsetX(topFacing, 1) + 2D / 16D + XSTR_INSTANCE.nextFloat() * 14D / 16D;
                 final double y = aBaseMetaTileEntity.getOffsetY(topFacing, 1) + 1D / 32D;
-                final double z = aBaseMetaTileEntity.getOffsetZ(topFacing, 1) + 2D / 16D
-                    + XSTR_INSTANCE.nextFloat() * 14D / 16D;
+                final double z =
+                        aBaseMetaTileEntity.getOffsetZ(topFacing, 1) + 2D / 16D + XSTR_INSTANCE.nextFloat() * 14D / 16D;
 
                 new ParticleEventBuilder()
-                    .setMotion(0D, 0D, 0D)
-                    .setPosition(x, y, z)
-                    .setWorld(getBaseMetaTileEntity().getWorld())
-                    .setIdentifier(ParticleFX.SMOKE).run();
+                        .setMotion(0D, 0D, 0D)
+                        .setPosition(x, y, z)
+                        .setWorld(getBaseMetaTileEntity().getWorld())
+                        .setIdentifier(ParticleFX.SMOKE)
+                        .run();
             }
         }
     }
 
     @Override
     public ITexture[] getFront(byte aColor) {
-        return new ITexture[]{super.getFront(aColor)[0], TextureFactory.of(
-                TextureFactory.of(DIESEL_GENERATOR_FRONT),
-                TextureFactory.builder().addIcon(DIESEL_GENERATOR_FRONT_GLOW).glow().build()),
-                OVERLAYS_ENERGY_OUT[this.mTier]};
+        return new ITexture[] {
+            super.getFront(aColor)[0],
+            TextureFactory.of(
+                    TextureFactory.of(DIESEL_GENERATOR_FRONT),
+                    TextureFactory.builder()
+                            .addIcon(DIESEL_GENERATOR_FRONT_GLOW)
+                            .glow()
+                            .build()),
+            OVERLAYS_ENERGY_OUT[this.mTier]
+        };
     }
 
     @Override
     public ITexture[] getBack(byte aColor) {
-        return new ITexture[]{super.getBack(aColor)[0], TextureFactory.of(
-                TextureFactory.of(DIESEL_GENERATOR_BACK),
-                TextureFactory.builder().addIcon(DIESEL_GENERATOR_BACK_GLOW).glow().build())};
+        return new ITexture[] {
+            super.getBack(aColor)[0],
+            TextureFactory.of(
+                    TextureFactory.of(DIESEL_GENERATOR_BACK),
+                    TextureFactory.builder()
+                            .addIcon(DIESEL_GENERATOR_BACK_GLOW)
+                            .glow()
+                            .build())
+        };
     }
 
     @Override
     public ITexture[] getBottom(byte aColor) {
-        return new ITexture[]{super.getBottom(aColor)[0], TextureFactory.of(
-                TextureFactory.of(DIESEL_GENERATOR_BOTTOM),
-                TextureFactory.builder().addIcon(DIESEL_GENERATOR_BOTTOM_GLOW).glow().build())};
+        return new ITexture[] {
+            super.getBottom(aColor)[0],
+            TextureFactory.of(
+                    TextureFactory.of(DIESEL_GENERATOR_BOTTOM),
+                    TextureFactory.builder()
+                            .addIcon(DIESEL_GENERATOR_BOTTOM_GLOW)
+                            .glow()
+                            .build())
+        };
     }
 
     @Override
     public ITexture[] getTop(byte aColor) {
-        return new ITexture[]{super.getTop(aColor)[0], TextureFactory.of(
-                TextureFactory.of(DIESEL_GENERATOR_TOP),
-                TextureFactory.builder().addIcon(DIESEL_GENERATOR_TOP_GLOW).glow().build())};
+        return new ITexture[] {
+            super.getTop(aColor)[0],
+            TextureFactory.of(
+                    TextureFactory.of(DIESEL_GENERATOR_TOP),
+                    TextureFactory.builder()
+                            .addIcon(DIESEL_GENERATOR_TOP_GLOW)
+                            .glow()
+                            .build())
+        };
     }
 
     @Override
     public ITexture[] getSides(byte aColor) {
-        return new ITexture[]{super.getSides(aColor)[0], TextureFactory.of(
-                TextureFactory.of(DIESEL_GENERATOR_SIDE),
-                TextureFactory.builder().addIcon(DIESEL_GENERATOR_SIDE_GLOW).glow().build())};
+        return new ITexture[] {
+            super.getSides(aColor)[0],
+            TextureFactory.of(
+                    TextureFactory.of(DIESEL_GENERATOR_SIDE),
+                    TextureFactory.builder()
+                            .addIcon(DIESEL_GENERATOR_SIDE_GLOW)
+                            .glow()
+                            .build())
+        };
     }
 
     @Override
     public ITexture[] getFrontActive(byte aColor) {
-        return new ITexture[]{super.getFrontActive(aColor)[0], TextureFactory.of(
-                TextureFactory.of(DIESEL_GENERATOR_FRONT_ACTIVE),
-                TextureFactory.builder().addIcon(DIESEL_GENERATOR_FRONT_ACTIVE_GLOW).glow().build()),
-                OVERLAYS_ENERGY_OUT[this.mTier]};
+        return new ITexture[] {
+            super.getFrontActive(aColor)[0],
+            TextureFactory.of(
+                    TextureFactory.of(DIESEL_GENERATOR_FRONT_ACTIVE),
+                    TextureFactory.builder()
+                            .addIcon(DIESEL_GENERATOR_FRONT_ACTIVE_GLOW)
+                            .glow()
+                            .build()),
+            OVERLAYS_ENERGY_OUT[this.mTier]
+        };
     }
 
     @Override
     public ITexture[] getBackActive(byte aColor) {
-        return new ITexture[]{super.getBackActive(aColor)[0], TextureFactory.of(
-                TextureFactory.of(DIESEL_GENERATOR_BACK_ACTIVE),
-                TextureFactory.builder().addIcon(DIESEL_GENERATOR_BACK_ACTIVE_GLOW).glow().build())};
+        return new ITexture[] {
+            super.getBackActive(aColor)[0],
+            TextureFactory.of(
+                    TextureFactory.of(DIESEL_GENERATOR_BACK_ACTIVE),
+                    TextureFactory.builder()
+                            .addIcon(DIESEL_GENERATOR_BACK_ACTIVE_GLOW)
+                            .glow()
+                            .build())
+        };
     }
 
     @Override
     public ITexture[] getBottomActive(byte aColor) {
-        return new ITexture[]{super.getBottomActive(aColor)[0], TextureFactory.of(
-                TextureFactory.of(DIESEL_GENERATOR_BOTTOM_ACTIVE),
-                TextureFactory.builder().addIcon(DIESEL_GENERATOR_BOTTOM_ACTIVE_GLOW).glow().build())};
+        return new ITexture[] {
+            super.getBottomActive(aColor)[0],
+            TextureFactory.of(
+                    TextureFactory.of(DIESEL_GENERATOR_BOTTOM_ACTIVE),
+                    TextureFactory.builder()
+                            .addIcon(DIESEL_GENERATOR_BOTTOM_ACTIVE_GLOW)
+                            .glow()
+                            .build())
+        };
     }
 
     @Override
     public ITexture[] getTopActive(byte aColor) {
-        return new ITexture[]{super.getTopActive(aColor)[0], TextureFactory.of(
-                TextureFactory.of(DIESEL_GENERATOR_TOP_ACTIVE),
-                TextureFactory.builder().addIcon(DIESEL_GENERATOR_TOP_ACTIVE_GLOW).glow().build())};
+        return new ITexture[] {
+            super.getTopActive(aColor)[0],
+            TextureFactory.of(
+                    TextureFactory.of(DIESEL_GENERATOR_TOP_ACTIVE),
+                    TextureFactory.builder()
+                            .addIcon(DIESEL_GENERATOR_TOP_ACTIVE_GLOW)
+                            .glow()
+                            .build())
+        };
     }
 
     @Override
     public ITexture[] getSidesActive(byte aColor) {
-        return new ITexture[]{super.getSidesActive(aColor)[0], TextureFactory.of(
-                TextureFactory.of(DIESEL_GENERATOR_SIDE_ACTIVE),
-                TextureFactory.builder().addIcon(DIESEL_GENERATOR_SIDE_ACTIVE_GLOW).glow().build())};
+        return new ITexture[] {
+            super.getSidesActive(aColor)[0],
+            TextureFactory.of(
+                    TextureFactory.of(DIESEL_GENERATOR_SIDE_ACTIVE),
+                    TextureFactory.builder()
+                            .addIcon(DIESEL_GENERATOR_SIDE_ACTIVE_GLOW)
+                            .glow()
+                            .build())
+        };
     }
 
     @Override
     public int getPollution() {
-        return (int) (GT_Mod.gregtechproxy.mPollutionBaseDieselGeneratorPerSecond * GT_Mod.gregtechproxy.mPollutionDieselGeneratorReleasedByTier[mTier]);
+        return (int) (GT_Mod.gregtechproxy.mPollutionBaseDieselGeneratorPerSecond
+                * GT_Mod.gregtechproxy.mPollutionDieselGeneratorReleasedByTier[mTier]);
     }
 }
diff --git a/src/main/java/gregtech/common/tileentities/generators/GT_MetaTileEntity_GasTurbine.java b/src/main/java/gregtech/common/tileentities/generators/GT_MetaTileEntity_GasTurbine.java
index a0f6aeee64..6a5ee85d99 100644
--- a/src/main/java/gregtech/common/tileentities/generators/GT_MetaTileEntity_GasTurbine.java
+++ b/src/main/java/gregtech/common/tileentities/generators/GT_MetaTileEntity_GasTurbine.java
@@ -1,5 +1,7 @@
 package gregtech.common.tileentities.generators;
 
+import static gregtech.api.enums.Textures.BlockIcons.*;
+
 import gregtech.GT_Mod;
 import gregtech.api.GregTech_API;
 import gregtech.api.enums.ConfigCategories;
@@ -10,17 +12,18 @@ import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_BasicGenera
 import gregtech.api.render.TextureFactory;
 import gregtech.api.util.GT_Recipe;
 
-import static gregtech.api.enums.Textures.BlockIcons.*;
-
 public class GT_MetaTileEntity_GasTurbine extends GT_MetaTileEntity_BasicGenerator {
 
-
     public int mEfficiency;
 
     public GT_MetaTileEntity_GasTurbine(int aID, String aName, String aNameRegional, int aTier) {
-        super(aID, aName, aNameRegional, aTier, new String[]{
-                "Requires flammable Gasses",
-                "Causes " + (int) (GT_Mod.gregtechproxy.mPollutionBaseGasTurbinePerSecond * GT_Mod.gregtechproxy.mPollutionGasTurbineReleasedByTier[aTier]) + " Pollution per second"});
+        super(aID, aName, aNameRegional, aTier, new String[] {
+            "Requires flammable Gasses",
+            "Causes "
+                    + (int) (GT_Mod.gregtechproxy.mPollutionBaseGasTurbinePerSecond
+                            * GT_Mod.gregtechproxy.mPollutionGasTurbineReleasedByTier[aTier])
+                    + " Pollution per second"
+        });
         onConfigLoad();
     }
 
@@ -55,10 +58,10 @@ public class GT_MetaTileEntity_GasTurbine extends GT_MetaTileEntity_BasicGenerat
     }
 
     public void onConfigLoad() {
-        this.mEfficiency = GregTech_API.sMachineFile.get(ConfigCategories.machineconfig, "GasTurbine.efficiency.tier." + this.mTier, (100 - this.mTier * 5));
+        this.mEfficiency = GregTech_API.sMachineFile.get(
+                ConfigCategories.machineconfig, "GasTurbine.efficiency.tier." + this.mTier, (100 - this.mTier * 5));
     }
 
-
     @Override
     public int getEfficiency() {
         return this.mEfficiency;
@@ -66,78 +69,139 @@ public class GT_MetaTileEntity_GasTurbine extends GT_MetaTileEntity_BasicGenerat
 
     @Override
     public ITexture[] getFront(byte aColor) {
-        return new ITexture[]{super.getFront(aColor)[0], TextureFactory.of(
-                TextureFactory.of(GAS_TURBINE_FRONT),
-                TextureFactory.builder().addIcon(GAS_TURBINE_FRONT_GLOW).glow().build()),
-                OVERLAYS_ENERGY_OUT[this.mTier]};
+        return new ITexture[] {
+            super.getFront(aColor)[0],
+            TextureFactory.of(
+                    TextureFactory.of(GAS_TURBINE_FRONT),
+                    TextureFactory.builder()
+                            .addIcon(GAS_TURBINE_FRONT_GLOW)
+                            .glow()
+                            .build()),
+            OVERLAYS_ENERGY_OUT[this.mTier]
+        };
     }
 
     @Override
     public ITexture[] getBack(byte aColor) {
-        return new ITexture[]{super.getBack(aColor)[0], TextureFactory.of(
-                TextureFactory.of(GAS_TURBINE_BACK),
-                TextureFactory.builder().addIcon(GAS_TURBINE_BACK_GLOW).glow().build())};
+        return new ITexture[] {
+            super.getBack(aColor)[0],
+            TextureFactory.of(
+                    TextureFactory.of(GAS_TURBINE_BACK),
+                    TextureFactory.builder()
+                            .addIcon(GAS_TURBINE_BACK_GLOW)
+                            .glow()
+                            .build())
+        };
     }
 
     @Override
     public ITexture[] getBottom(byte aColor) {
-        return new ITexture[]{super.getBottom(aColor)[0], TextureFactory.of(
-                TextureFactory.of(GAS_TURBINE_BOTTOM),
-                TextureFactory.builder().addIcon(GAS_TURBINE_BOTTOM_GLOW).glow().build())};
+        return new ITexture[] {
+            super.getBottom(aColor)[0],
+            TextureFactory.of(
+                    TextureFactory.of(GAS_TURBINE_BOTTOM),
+                    TextureFactory.builder()
+                            .addIcon(GAS_TURBINE_BOTTOM_GLOW)
+                            .glow()
+                            .build())
+        };
     }
 
     @Override
     public ITexture[] getTop(byte aColor) {
-        return new ITexture[]{super.getTop(aColor)[0], TextureFactory.of(
-                TextureFactory.of(GAS_TURBINE_TOP),
-                TextureFactory.builder().addIcon(GAS_TURBINE_TOP_GLOW).glow().build())};
+        return new ITexture[] {
+            super.getTop(aColor)[0],
+            TextureFactory.of(
+                    TextureFactory.of(GAS_TURBINE_TOP),
+                    TextureFactory.builder()
+                            .addIcon(GAS_TURBINE_TOP_GLOW)
+                            .glow()
+                            .build())
+        };
     }
 
     @Override
     public ITexture[] getSides(byte aColor) {
-        return new ITexture[]{super.getSides(aColor)[0], TextureFactory.of(
-                TextureFactory.of(GAS_TURBINE_SIDE),
-                TextureFactory.builder().addIcon(GAS_TURBINE_SIDE_GLOW).glow().build())};
+        return new ITexture[] {
+            super.getSides(aColor)[0],
+            TextureFactory.of(
+                    TextureFactory.of(GAS_TURBINE_SIDE),
+                    TextureFactory.builder()
+                            .addIcon(GAS_TURBINE_SIDE_GLOW)
+                            .glow()
+                            .build())
+        };
     }
 
     @Override
     public ITexture[] getFrontActive(byte aColor) {
-        return new ITexture[]{super.getFrontActive(aColor)[0], TextureFactory.of(
-                TextureFactory.of(GAS_TURBINE_FRONT_ACTIVE),
-                TextureFactory.builder().addIcon(GAS_TURBINE_FRONT_ACTIVE_GLOW).glow().build()),
-                OVERLAYS_ENERGY_OUT[this.mTier]};
+        return new ITexture[] {
+            super.getFrontActive(aColor)[0],
+            TextureFactory.of(
+                    TextureFactory.of(GAS_TURBINE_FRONT_ACTIVE),
+                    TextureFactory.builder()
+                            .addIcon(GAS_TURBINE_FRONT_ACTIVE_GLOW)
+                            .glow()
+                            .build()),
+            OVERLAYS_ENERGY_OUT[this.mTier]
+        };
     }
 
     @Override
     public ITexture[] getBackActive(byte aColor) {
-        return new ITexture[]{super.getBackActive(aColor)[0], TextureFactory.of(
-                TextureFactory.of(GAS_TURBINE_BACK_ACTIVE),
-                TextureFactory.builder().addIcon(GAS_TURBINE_BACK_ACTIVE_GLOW).glow().build())};
+        return new ITexture[] {
+            super.getBackActive(aColor)[0],
+            TextureFactory.of(
+                    TextureFactory.of(GAS_TURBINE_BACK_ACTIVE),
+                    TextureFactory.builder()
+                            .addIcon(GAS_TURBINE_BACK_ACTIVE_GLOW)
+                            .glow()
+                            .build())
+        };
     }
 
     @Override
     public ITexture[] getBottomActive(byte aColor) {
-        return new ITexture[]{super.getBottomActive(aColor)[0], TextureFactory.of(
-                TextureFactory.of(GAS_TURBINE_BOTTOM_ACTIVE),
-                TextureFactory.builder().addIcon(GAS_TURBINE_BOTTOM_ACTIVE_GLOW).glow().build())};
+        return new ITexture[] {
+            super.getBottomActive(aColor)[0],
+            TextureFactory.of(
+                    TextureFactory.of(GAS_TURBINE_BOTTOM_ACTIVE),
+                    TextureFactory.builder()
+                            .addIcon(GAS_TURBINE_BOTTOM_ACTIVE_GLOW)
+                            .glow()
+                            .build())
+        };
     }
 
     @Override
     public ITexture[] getTopActive(byte aColor) {
-        return new ITexture[]{super.getTopActive(aColor)[0], TextureFactory.of(
-                TextureFactory.of(GAS_TURBINE_TOP_ACTIVE),
-                TextureFactory.builder().addIcon(GAS_TURBINE_TOP_ACTIVE_GLOW).glow().build())};
+        return new ITexture[] {
+            super.getTopActive(aColor)[0],
+            TextureFactory.of(
+                    TextureFactory.of(GAS_TURBINE_TOP_ACTIVE),
+                    TextureFactory.builder()
+                            .addIcon(GAS_TURBINE_TOP_ACTIVE_GLOW)
+                            .glow()
+                            .build())
+        };
     }
 
     @Override
     public ITexture[] getSidesActive(byte aColor) {
-        return new ITexture[]{super.getSidesActive(aColor)[0], TextureFactory.of(
-                TextureFactory.of(GAS_TURBINE_SIDE_ACTIVE),
-                TextureFactory.builder().addIcon(GAS_TURBINE_SIDE_ACTIVE_GLOW).glow().build())};
+        return new ITexture[] {
+            super.getSidesActive(aColor)[0],
+            TextureFactory.of(
+                    TextureFactory.of(GAS_TURBINE_SIDE_ACTIVE),
+                    TextureFactory.builder()
+                            .addIcon(GAS_TURBINE_SIDE_ACTIVE_GLOW)
+                            .glow()
+                            .build())
+        };
     }
 
     @Override
     public int getPollution() {
-        return (int) (GT_Mod.gregtechproxy.mPollutionBaseGasTurbinePerSecond * GT_Mod.gregtechproxy.mPollutionGasTurbineReleasedByTier[mTier]);
+        return (int) (GT_Mod.gregtechproxy.mPollutionBaseGasTurbinePerSecond
+                * GT_Mod.gregtechproxy.mPollutionGasTurbineReleasedByTier[mTier]);
     }
 }
diff --git a/src/main/java/gregtech/common/tileentities/generators/GT_MetaTileEntity_LightningRod.java b/src/main/java/gregtech/common/tileentities/generators/GT_MetaTileEntity_LightningRod.java
index 88d49075e5..dbb8931848 100644
--- a/src/main/java/gregtech/common/tileentities/generators/GT_MetaTileEntity_LightningRod.java
+++ b/src/main/java/gregtech/common/tileentities/generators/GT_MetaTileEntity_LightningRod.java
@@ -1,5 +1,7 @@
 package gregtech.common.tileentities.generators;
 
+import static gregtech.api.objects.XSTR.XSTR_INSTANCE;
+
 import gregtech.api.enums.GT_Values;
 import gregtech.api.enums.Textures.BlockIcons;
 import gregtech.api.interfaces.ITexture;
@@ -14,36 +16,46 @@ import net.minecraft.nbt.NBTTagCompound;
 import net.minecraft.world.World;
 import net.minecraftforge.common.util.ForgeDirection;
 
-import static gregtech.api.objects.XSTR.XSTR_INSTANCE;
-
 public class GT_MetaTileEntity_LightningRod extends GT_MetaTileEntity_TieredMachineBlock {
     public GT_MetaTileEntity_LightningRod(int aID, String aName, String aNameRegional, int aTier) {
         super(aID, aName, aNameRegional, aTier, 0, "Generates EU From Lightning Bolts");
     }
 
-    public GT_MetaTileEntity_LightningRod(String aName, int aTier, int aInvSlotCount, String aDescription, ITexture[][][] aTextures) {
+    public GT_MetaTileEntity_LightningRod(
+            String aName, int aTier, int aInvSlotCount, String aDescription, ITexture[][][] aTextures) {
         super(aName, aTier, aInvSlotCount, aDescription, aTextures);
     }
-    
-    public GT_MetaTileEntity_LightningRod(String aName, int aTier, int aInvSlotCount, String[] aDescription, ITexture[][][] aTextures) {
+
+    public GT_MetaTileEntity_LightningRod(
+            String aName, int aTier, int aInvSlotCount, String[] aDescription, ITexture[][][] aTextures) {
         super(aName, aTier, aInvSlotCount, aDescription, aTextures);
     }
 
     @Override
-    public ITexture[] getTexture(IGregTechTileEntity aBaseMetaTileEntity, byte aSide, byte aFacing, byte aColorIndex, boolean aActive, boolean aRedstone) {
+    public ITexture[] getTexture(
+            IGregTechTileEntity aBaseMetaTileEntity,
+            byte aSide,
+            byte aFacing,
+            byte aColorIndex,
+            boolean aActive,
+            boolean aRedstone) {
         if (aSide != ForgeDirection.UP.ordinal()) {
-            return new ITexture[]{
-                    BlockIcons.MACHINE_CASINGS[mTier][aColorIndex + 1],
-                    BlockIcons.OVERLAYS_ENERGY_OUT_POWER[mTier]};
+            return new ITexture[] {
+                BlockIcons.MACHINE_CASINGS[mTier][aColorIndex + 1], BlockIcons.OVERLAYS_ENERGY_OUT_POWER[mTier]
+            };
         }
-        if (!aActive) return new ITexture[]{
+        if (!aActive)
+            return new ITexture[] {
                 BlockIcons.MACHINE_CASINGS[mTier][aColorIndex + 1],
                 TextureFactory.of(BlockIcons.MACHINE_CASING_FUSION_GLASS)
-        };
-        return new ITexture[]{
-                BlockIcons.MACHINE_CASINGS[mTier][aColorIndex + 1],
-                TextureFactory.of(BlockIcons.MACHINE_CASING_FUSION_GLASS_YELLOW),
-                TextureFactory.builder().addIcon(BlockIcons.MACHINE_CASING_FUSION_GLASS_YELLOW_GLOW).glow().build()
+            };
+        return new ITexture[] {
+            BlockIcons.MACHINE_CASINGS[mTier][aColorIndex + 1],
+            TextureFactory.of(BlockIcons.MACHINE_CASING_FUSION_GLASS_YELLOW),
+            TextureFactory.builder()
+                    .addIcon(BlockIcons.MACHINE_CASING_FUSION_GLASS_YELLOW_GLOW)
+                    .glow()
+                    .build()
         };
     }
 
@@ -54,7 +66,8 @@ public class GT_MetaTileEntity_LightningRod extends GT_MetaTileEntity_TieredMach
 
     @Override
     public IMetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) {
-        return new GT_MetaTileEntity_LightningRod(this.mName, this.mTier, this.mInventory.length, this.mDescriptionArray, this.mTextures);
+        return new GT_MetaTileEntity_LightningRod(
+                this.mName, this.mTier, this.mInventory.length, this.mDescriptionArray, this.mTextures);
     }
 
     @Override
@@ -76,7 +89,11 @@ public class GT_MetaTileEntity_LightningRod extends GT_MetaTileEntity_TieredMach
                 int aZ = aBaseMetaTileEntity.getZCoord();
 
                 for (int i = aBaseMetaTileEntity.getYCoord() + 1; i < aWorld.getHeight() - 1; i++) {
-                    if (isRodValid && aBaseMetaTileEntity.getBlock(aX, i, aZ).getUnlocalizedName().equals("blockFenceIron")) {
+                    if (isRodValid
+                            && aBaseMetaTileEntity
+                                    .getBlock(aX, i, aZ)
+                                    .getUnlocalizedName()
+                                    .equals("blockFenceIron")) {
                         aRodValue++;
                     } else {
                         isRodValid = false;
@@ -88,7 +105,8 @@ public class GT_MetaTileEntity_LightningRod extends GT_MetaTileEntity_TieredMach
                 }
                 if (!aWorld.isThundering() && ((aY + aRodValue) < 128)) aRodValue = 0;
                 if (XSTR_INSTANCE.nextInt(4 * aWorld.getHeight()) < (aRodValue * (aY + aRodValue))) {
-                    aBaseMetaTileEntity.increaseStoredEnergyUnits(maxEUStore() - aBaseMetaTileEntity.getStoredEU(), false);
+                    aBaseMetaTileEntity.increaseStoredEnergyUnits(
+                            maxEUStore() - aBaseMetaTileEntity.getStoredEU(), false);
                     aWorld.addWeatherEffect(new EntityLightningBolt(aWorld, aX, aY + aRodValue, aZ));
                 }
             }
@@ -112,7 +130,7 @@ public class GT_MetaTileEntity_LightningRod extends GT_MetaTileEntity_TieredMach
 
     @Override
     public boolean isFacingValid(byte aFacing) {
-        return aFacing==1;
+        return aFacing == 1;
     }
 
     @Override
@@ -146,10 +164,8 @@ public class GT_MetaTileEntity_LightningRod extends GT_MetaTileEntity_TieredMach
     }
 
     @Override
-    public void saveNBTData(NBTTagCompound aNBT) {
-    }
+    public void saveNBTData(NBTTagCompound aNBT) {}
 
     @Override
-    public void loadNBTData(NBTTagCompound aNBT) {
-    }
+    public void loadNBTData(NBTTagCompound aNBT) {}
 }
diff --git a/src/main/java/gregtech/common/tileentities/generators/GT_MetaTileEntity_MagicEnergyConverter.java b/src/main/java/gregtech/common/tileentities/generators/GT_MetaTileEntity_MagicEnergyConverter.java
index aceab00a02..2e1bfd655f 100644
--- a/src/main/java/gregtech/common/tileentities/generators/GT_MetaTileEntity_MagicEnergyConverter.java
+++ b/src/main/java/gregtech/common/tileentities/generators/GT_MetaTileEntity_MagicEnergyConverter.java
@@ -1,14 +1,5 @@
 package gregtech.common.tileentities.generators;
 
-import gregtech.api.GregTech_API;
-import gregtech.api.enums.ConfigCategories;
-import gregtech.api.interfaces.ITexture;
-import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
-import gregtech.api.metatileentity.MetaTileEntity;
-import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_BasicGenerator;
-import gregtech.api.render.TextureFactory;
-import gregtech.api.util.GT_Recipe;
-
 import static gregtech.api.enums.Textures.BlockIcons.MACHINE_CASING_MAGIC;
 import static gregtech.api.enums.Textures.BlockIcons.MACHINE_CASING_MAGIC_ACTIVE;
 import static gregtech.api.enums.Textures.BlockIcons.MACHINE_CASING_MAGIC_ACTIVE_GLOW;
@@ -19,6 +10,15 @@ import static gregtech.api.enums.Textures.BlockIcons.MACHINE_CASING_MAGIC_FRONT_
 import static gregtech.api.enums.Textures.BlockIcons.MACHINE_CASING_MAGIC_GLOW;
 import static gregtech.api.enums.Textures.BlockIcons.OVERLAYS_ENERGY_OUT;
 
+import gregtech.api.GregTech_API;
+import gregtech.api.enums.ConfigCategories;
+import gregtech.api.interfaces.ITexture;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.metatileentity.MetaTileEntity;
+import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_BasicGenerator;
+import gregtech.api.render.TextureFactory;
+import gregtech.api.util.GT_Recipe;
+
 public class GT_MetaTileEntity_MagicEnergyConverter extends GT_MetaTileEntity_BasicGenerator {
     public int mEfficiency;
 
@@ -27,12 +27,14 @@ public class GT_MetaTileEntity_MagicEnergyConverter extends GT_MetaTileEntity_Ba
         onConfigLoad();
     }
 
-    public GT_MetaTileEntity_MagicEnergyConverter(String aName, int aTier, String aDescription, ITexture[][][] aTextures) {
+    public GT_MetaTileEntity_MagicEnergyConverter(
+            String aName, int aTier, String aDescription, ITexture[][][] aTextures) {
         super(aName, aTier, aDescription, aTextures);
         onConfigLoad();
     }
 
-    public GT_MetaTileEntity_MagicEnergyConverter(String aName, int aTier, String[] aDescription, ITexture[][][] aTextures) {
+    public GT_MetaTileEntity_MagicEnergyConverter(
+            String aName, int aTier, String[] aDescription, ITexture[][][] aTextures) {
         super(aName, aTier, aDescription, aTextures);
         onConfigLoad();
     }
@@ -44,7 +46,8 @@ public class GT_MetaTileEntity_MagicEnergyConverter extends GT_MetaTileEntity_Ba
 
     @Override
     public MetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) {
-        return new GT_MetaTileEntity_MagicEnergyConverter(this.mName, this.mTier, this.mDescriptionArray, this.mTextures);
+        return new GT_MetaTileEntity_MagicEnergyConverter(
+                this.mName, this.mTier, this.mDescriptionArray, this.mTextures);
     }
 
     @Override
@@ -58,10 +61,12 @@ public class GT_MetaTileEntity_MagicEnergyConverter extends GT_MetaTileEntity_Ba
     }
 
     public void onConfigLoad() {
-        this.mEfficiency = GregTech_API.sMachineFile.get(ConfigCategories.machineconfig, "MagicEnergyConverter.efficiency.tier." + this.mTier, 100 - this.mTier * 5);
+        this.mEfficiency = GregTech_API.sMachineFile.get(
+                ConfigCategories.machineconfig,
+                "MagicEnergyConverter.efficiency.tier." + this.mTier,
+                100 - this.mTier * 5);
     }
 
-
     @Override
     public int getEfficiency() {
         return this.mEfficiency;
@@ -69,88 +74,116 @@ public class GT_MetaTileEntity_MagicEnergyConverter extends GT_MetaTileEntity_Ba
 
     @Override
     public ITexture[] getFront(byte aColor) {
-        return new ITexture[]{
-                super.getFront(aColor)[0],
-                TextureFactory.of(MACHINE_CASING_MAGIC),
-                TextureFactory.builder().addIcon(MACHINE_CASING_MAGIC_GLOW).glow().build(),
-                OVERLAYS_ENERGY_OUT[mTier]};
+        return new ITexture[] {
+            super.getFront(aColor)[0],
+            TextureFactory.of(MACHINE_CASING_MAGIC),
+            TextureFactory.builder().addIcon(MACHINE_CASING_MAGIC_GLOW).glow().build(),
+            OVERLAYS_ENERGY_OUT[mTier]
+        };
     }
 
     @Override
     public ITexture[] getBack(byte aColor) {
-        return new ITexture[]{
-                super.getBack(aColor)[0],
-                TextureFactory.of(MACHINE_CASING_MAGIC_FRONT),
-                TextureFactory.builder().addIcon(MACHINE_CASING_MAGIC_FRONT_GLOW).glow().build()};
+        return new ITexture[] {
+            super.getBack(aColor)[0],
+            TextureFactory.of(MACHINE_CASING_MAGIC_FRONT),
+            TextureFactory.builder()
+                    .addIcon(MACHINE_CASING_MAGIC_FRONT_GLOW)
+                    .glow()
+                    .build()
+        };
     }
 
     @Override
     public ITexture[] getBottom(byte aColor) {
-        return new ITexture[]{
-                super.getBottom(aColor)[0],
-                TextureFactory.of(MACHINE_CASING_MAGIC),
-                TextureFactory.builder().addIcon(MACHINE_CASING_MAGIC_GLOW).glow().build()};
+        return new ITexture[] {
+            super.getBottom(aColor)[0],
+            TextureFactory.of(MACHINE_CASING_MAGIC),
+            TextureFactory.builder().addIcon(MACHINE_CASING_MAGIC_GLOW).glow().build()
+        };
     }
 
     @Override
     public ITexture[] getTop(byte aColor) {
-        return new ITexture[]{
-                super.getTop(aColor)[0],
-                TextureFactory.of(MACHINE_CASING_MAGIC),
-                TextureFactory.builder().addIcon(MACHINE_CASING_MAGIC_GLOW).glow().build()};
+        return new ITexture[] {
+            super.getTop(aColor)[0],
+            TextureFactory.of(MACHINE_CASING_MAGIC),
+            TextureFactory.builder().addIcon(MACHINE_CASING_MAGIC_GLOW).glow().build()
+        };
     }
 
     @Override
     public ITexture[] getSides(byte aColor) {
-        return new ITexture[]{
-                super.getSides(aColor)[0],
-                TextureFactory.of(MACHINE_CASING_MAGIC),
-                TextureFactory.builder().addIcon(MACHINE_CASING_MAGIC_GLOW).glow().build()};
+        return new ITexture[] {
+            super.getSides(aColor)[0],
+            TextureFactory.of(MACHINE_CASING_MAGIC),
+            TextureFactory.builder().addIcon(MACHINE_CASING_MAGIC_GLOW).glow().build()
+        };
     }
 
     @Override
     public ITexture[] getFrontActive(byte aColor) {
-        return new ITexture[]{
-                super.getFrontActive(aColor)[0],
-                TextureFactory.of(MACHINE_CASING_MAGIC_ACTIVE),
-                TextureFactory.builder().addIcon(MACHINE_CASING_MAGIC_ACTIVE_GLOW).glow().build(),
-                OVERLAYS_ENERGY_OUT[mTier]};
+        return new ITexture[] {
+            super.getFrontActive(aColor)[0],
+            TextureFactory.of(MACHINE_CASING_MAGIC_ACTIVE),
+            TextureFactory.builder()
+                    .addIcon(MACHINE_CASING_MAGIC_ACTIVE_GLOW)
+                    .glow()
+                    .build(),
+            OVERLAYS_ENERGY_OUT[mTier]
+        };
     }
 
     @Override
     public ITexture[] getBackActive(byte aColor) {
-        return new ITexture[]{
-                super.getBackActive(aColor)[0],
-                TextureFactory.of(MACHINE_CASING_MAGIC_FRONT_ACTIVE),
-                TextureFactory.builder().addIcon(MACHINE_CASING_MAGIC_FRONT_ACTIVE_GLOW).glow().build()};
+        return new ITexture[] {
+            super.getBackActive(aColor)[0],
+            TextureFactory.of(MACHINE_CASING_MAGIC_FRONT_ACTIVE),
+            TextureFactory.builder()
+                    .addIcon(MACHINE_CASING_MAGIC_FRONT_ACTIVE_GLOW)
+                    .glow()
+                    .build()
+        };
     }
 
     @Override
     public ITexture[] getBottomActive(byte aColor) {
-        return new ITexture[]{
-                super.getBottomActive(aColor)[0],
-                TextureFactory.of(MACHINE_CASING_MAGIC_ACTIVE),
-                TextureFactory.builder().addIcon(MACHINE_CASING_MAGIC_ACTIVE_GLOW).glow().build()};
+        return new ITexture[] {
+            super.getBottomActive(aColor)[0],
+            TextureFactory.of(MACHINE_CASING_MAGIC_ACTIVE),
+            TextureFactory.builder()
+                    .addIcon(MACHINE_CASING_MAGIC_ACTIVE_GLOW)
+                    .glow()
+                    .build()
+        };
     }
 
     @Override
     public ITexture[] getTopActive(byte aColor) {
-        return new ITexture[]{
-                super.getTopActive(aColor)[0],
-                TextureFactory.of(MACHINE_CASING_MAGIC_ACTIVE),
-                TextureFactory.builder().addIcon(MACHINE_CASING_MAGIC_ACTIVE_GLOW).glow().build()};
+        return new ITexture[] {
+            super.getTopActive(aColor)[0],
+            TextureFactory.of(MACHINE_CASING_MAGIC_ACTIVE),
+            TextureFactory.builder()
+                    .addIcon(MACHINE_CASING_MAGIC_ACTIVE_GLOW)
+                    .glow()
+                    .build()
+        };
     }
 
     @Override
     public ITexture[] getSidesActive(byte aColor) {
-        return new ITexture[]{
-                super.getSidesActive(aColor)[0],
-                TextureFactory.of(MACHINE_CASING_MAGIC_ACTIVE),
-                TextureFactory.builder().addIcon(MACHINE_CASING_MAGIC_ACTIVE_GLOW).glow().build()};
+        return new ITexture[] {
+            super.getSidesActive(aColor)[0],
+            TextureFactory.of(MACHINE_CASING_MAGIC_ACTIVE),
+            TextureFactory.builder()
+                    .addIcon(MACHINE_CASING_MAGIC_ACTIVE_GLOW)
+                    .glow()
+                    .build()
+        };
     }
 
-	@Override
-	public int getPollution() {
-		return 0;
-	}
+    @Override
+    public int getPollution() {
+        return 0;
+    }
 }
diff --git a/src/main/java/gregtech/common/tileentities/generators/GT_MetaTileEntity_MagicalEnergyAbsorber.java b/src/main/java/gregtech/common/tileentities/generators/GT_MetaTileEntity_MagicalEnergyAbsorber.java
index 4158a22b47..210483cbe8 100644
--- a/src/main/java/gregtech/common/tileentities/generators/GT_MetaTileEntity_MagicalEnergyAbsorber.java
+++ b/src/main/java/gregtech/common/tileentities/generators/GT_MetaTileEntity_MagicalEnergyAbsorber.java
@@ -1,5 +1,17 @@
 package gregtech.common.tileentities.generators;
 
+import static gregtech.api.enums.ConfigCategories.machineconfig;
+import static gregtech.api.enums.GT_Values.MOD_ID_TC;
+import static gregtech.api.enums.GT_Values.V;
+import static gregtech.api.enums.Textures.BlockIcons.*;
+import static gregtech.api.objects.XSTR.XSTR_INSTANCE;
+import static net.minecraft.util.EnumChatFormatting.GRAY;
+import static net.minecraft.util.EnumChatFormatting.GREEN;
+import static net.minecraft.util.EnumChatFormatting.LIGHT_PURPLE;
+import static net.minecraft.util.EnumChatFormatting.RESET;
+import static net.minecraft.util.EnumChatFormatting.UNDERLINE;
+import static net.minecraft.util.EnumChatFormatting.YELLOW;
+
 import com.google.common.base.Enums;
 import cpw.mods.fml.common.Loader;
 import cpw.mods.fml.relauncher.Side;
@@ -18,6 +30,14 @@ import gregtech.api.util.GT_Log;
 import gregtech.api.util.GT_Recipe;
 import gregtech.api.util.GT_Utility;
 import gregtech.api.util.WorldSpawnedEventBuilder.ParticleEventBuilder;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+import java.util.Set;
+import java.util.UUID;
+import java.util.concurrent.ConcurrentHashMap;
 import net.minecraft.block.Block;
 import net.minecraft.block.BlockDragonEgg;
 import net.minecraft.enchantment.Enchantment;
@@ -40,36 +60,18 @@ import thaumcraft.api.aspects.AspectSourceHelper;
 import thaumcraft.api.aspects.IAspectContainer;
 import thaumcraft.api.visnet.VisNetHandler;
 
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Locale;
-import java.util.Map;
-import java.util.Set;
-import java.util.UUID;
-import java.util.concurrent.ConcurrentHashMap;
-
-import static gregtech.api.enums.ConfigCategories.machineconfig;
-import static gregtech.api.enums.GT_Values.MOD_ID_TC;
-import static gregtech.api.enums.GT_Values.V;
-import static gregtech.api.enums.Textures.BlockIcons.*;
-import static gregtech.api.objects.XSTR.XSTR_INSTANCE;
-import static net.minecraft.util.EnumChatFormatting.GRAY;
-import static net.minecraft.util.EnumChatFormatting.GREEN;
-import static net.minecraft.util.EnumChatFormatting.LIGHT_PURPLE;
-import static net.minecraft.util.EnumChatFormatting.RESET;
-import static net.minecraft.util.EnumChatFormatting.UNDERLINE;
-import static net.minecraft.util.EnumChatFormatting.YELLOW;
-
 interface MagicalEnergyBBListener {
     void onMagicalEnergyBBUpdate();
 }
 
-public class GT_MetaTileEntity_MagicalEnergyAbsorber extends GT_MetaTileEntity_BasicGenerator implements MagicalEnergyBBListener {
+public class GT_MetaTileEntity_MagicalEnergyAbsorber extends GT_MetaTileEntity_BasicGenerator
+        implements MagicalEnergyBBListener {
 
     private static final boolean THAUMCRAFT_LOADED = Loader.isModLoaded(MOD_ID_TC);
-    private static final ConcurrentHashMap<UUID, GT_MetaTileEntity_MagicalEnergyAbsorber> sSubscribedCrystals = new ConcurrentHashMap<>(4);
-    private static final List<Aspect> sPrimalAspects = (THAUMCRAFT_LOADED) ? Aspect.getPrimalAspects() : new ArrayList<>();
+    private static final ConcurrentHashMap<UUID, GT_MetaTileEntity_MagicalEnergyAbsorber> sSubscribedCrystals =
+            new ConcurrentHashMap<>(4);
+    private static final List<Aspect> sPrimalAspects =
+            (THAUMCRAFT_LOADED) ? Aspect.getPrimalAspects() : new ArrayList<>();
     private static final Map<Aspect, Integer> sAspectsEnergy = new HashMap<>();
     private static boolean sAllowMultipleEggs = false;
     private static GT_MetaTileEntity_MagicalEnergyAbsorber sActiveSiphon = null;
@@ -90,7 +92,8 @@ public class GT_MetaTileEntity_MagicalEnergyAbsorber extends GT_MetaTileEntity_B
         onConfigLoad(GregTech_API.sMachineFile);
     }
 
-    private GT_MetaTileEntity_MagicalEnergyAbsorber(String aName, int aTier, String[] aDescription, ITexture[][][] aTextures) {
+    private GT_MetaTileEntity_MagicalEnergyAbsorber(
+            String aName, int aTier, String[] aDescription, ITexture[][][] aTextures) {
         super(aName, aTier, aDescription, aTextures);
         onConfigLoad(GregTech_API.sMachineFile);
     }
@@ -110,10 +113,12 @@ public class GT_MetaTileEntity_MagicalEnergyAbsorber extends GT_MetaTileEntity_B
             sEnergyPerEssentia = aConfig.get(machineconfig, "MagicEnergyAbsorber.EnergyPerEssentia", 320);
             for (Aspect tAspect : Aspect.aspects.values()) {
                 //noinspection UnstableApiUsage
-                sAspectsEnergy.put(tAspect,
-                    Enums.getIfPresent(TC_Aspects.class,
-                        tAspect.getTag().toUpperCase(Locale.ENGLISH)).or(TC_Aspects.AER).mValue
-                        * sEnergyPerEssentia);
+                sAspectsEnergy.put(
+                        tAspect,
+                        Enums.getIfPresent(TC_Aspects.class, tAspect.getTag().toUpperCase(Locale.ENGLISH))
+                                        .or(TC_Aspects.AER)
+                                        .mValue
+                                * sEnergyPerEssentia);
             }
         }
     }
@@ -126,7 +131,8 @@ public class GT_MetaTileEntity_MagicalEnergyAbsorber extends GT_MetaTileEntity_B
     public void onConfigLoad(GT_Config aConfig) {
         sharedConfigLoad(aConfig);
         mEfficiency = aConfig.get(machineconfig, "MagicEnergyAbsorber.efficiency.tier." + mTier, 100 - mTier * 10);
-        mMaxVisPerDrain = (int) Math.round(Math.sqrt((double) (V[mTier] * 10000) / (sEnergyFromVis * (getEfficiency() != 0 ? getEfficiency() : 100))));
+        mMaxVisPerDrain = (int) Math.round(Math.sqrt(
+                (double) (V[mTier] * 10000) / (sEnergyFromVis * (getEfficiency() != 0 ? getEfficiency() : 100))));
         if (Math.pow(mMaxVisPerDrain, 2) * sEnergyFromVis * (getEfficiency() != 0 ? getEfficiency() : 100) < V[mTier]) {
             mMaxVisPerDrain += 1;
         }
@@ -136,7 +142,14 @@ public class GT_MetaTileEntity_MagicalEnergyAbsorber extends GT_MetaTileEntity_B
     public void onScrewdriverRightClick(byte aSide, EntityPlayer aPlayer, float aX, float aY, float aZ) {
         if (aPlayer.isSneaking()) mMagicalEnergyBB.decreaseTier();
         else mMagicalEnergyBB.increaseTier();
-        GT_Utility.sendChatToPlayer(aPlayer, String.format(GT_LanguageManager.addStringLocalization("Interaction_DESCRIPTION_MagicalEnergyAbsorber_Screwdriver", "Absorption range: %s blocks"), mMagicalEnergyBB.getRange(), true));
+        GT_Utility.sendChatToPlayer(
+                aPlayer,
+                String.format(
+                        GT_LanguageManager.addStringLocalization(
+                                "Interaction_DESCRIPTION_MagicalEnergyAbsorber_Screwdriver",
+                                "Absorption range: %s blocks"),
+                        mMagicalEnergyBB.getRange(),
+                        true));
         mMagicalEnergyBB.update();
     }
 
@@ -188,22 +201,27 @@ public class GT_MetaTileEntity_MagicalEnergyAbsorber extends GT_MetaTileEntity_B
         final String LI = "-%%%";
         final String EU_PER = "%%%EU per ";
         List<String> description = new ArrayList<>();
-        description.add(UNDERLINE + "Feasts on " + LIGHT_PURPLE + UNDERLINE + "magic" + GRAY + UNDERLINE + " close to it:");
-        description.add(LI + (sAllowMultipleEggs ? "A " : "An " + YELLOW + UNDERLINE + "EXCLUSIVE" + RESET) + GRAY + " " + LIGHT_PURPLE + "Dragon Egg" + GRAY + " atop");
+        description.add(
+                UNDERLINE + "Feasts on " + LIGHT_PURPLE + UNDERLINE + "magic" + GRAY + UNDERLINE + " close to it:");
+        description.add(LI + (sAllowMultipleEggs ? "A " : "An " + YELLOW + UNDERLINE + "EXCLUSIVE" + RESET) + GRAY + " "
+                + LIGHT_PURPLE + "Dragon Egg" + GRAY + " atop");
         if (sEnergyPerEndercrystal > 0) {
             description.add(LI + sEnergyPerEndercrystal + EU_PER + LIGHT_PURPLE + "Ender Crystal" + GRAY + " in range");
         }
         if (THAUMCRAFT_LOADED) {
             description.add(LI + mMaxVisPerDrain + "%%%CV/t from an " + LIGHT_PURPLE + "Energised Node" + GRAY);
-            description.add(LI + (sEnergyPerEssentia * getEfficiency()) / 100 + EU_PER + LIGHT_PURPLE + "Essentia" + GRAY + " Aspect-Value from containers in range");
+            description.add(LI + (sEnergyPerEssentia * getEfficiency()) / 100 + EU_PER + LIGHT_PURPLE + "Essentia"
+                    + GRAY + " Aspect-Value from containers in range");
         }
         description.add(" ");
         description.add(UNDERLINE + "Lookup range (Use Screwdriver to change):");
         description.add("Default:%%%" + GREEN + mMagicalEnergyBB.getDefaultRange());
         description.add("Max:%%%" + GREEN + mMagicalEnergyBB.getMaxRange());
         description.add(" ");
-        description.add(UNDERLINE + "Fuels on " + LIGHT_PURPLE + UNDERLINE + "enchantments" + GRAY + UNDERLINE + " input:");
-        description.add("- Item:%%%" + (10000 * getEfficiency()) / 100 + EU_PER + LIGHT_PURPLE + "enchant" + GRAY + " weight × level / max");
+        description.add(
+                UNDERLINE + "Fuels on " + LIGHT_PURPLE + UNDERLINE + "enchantments" + GRAY + UNDERLINE + " input:");
+        description.add("- Item:%%%" + (10000 * getEfficiency()) / 100 + EU_PER + LIGHT_PURPLE + "enchant" + GRAY
+                + " weight × level / max");
         description.add("- Book:%%%" + 10000 + EU_PER + LIGHT_PURPLE + "enchant" + GRAY + " weight × level / max");
         description.add(" ");
         description.add("Efficiency:%%%" + GREEN + getEfficiency() + "%");
@@ -212,84 +230,108 @@ public class GT_MetaTileEntity_MagicalEnergyAbsorber extends GT_MetaTileEntity_B
 
     @Override
     public ITexture[] getFront(byte aColor) {
-        return new ITexture[]{
+        return new ITexture[] {
             super.getFront(aColor)[0],
             TextureFactory.of(MACHINE_CASING_MAGIC),
             TextureFactory.builder().addIcon(MACHINE_CASING_MAGIC_GLOW).glow().build(),
-            OVERLAYS_ENERGY_OUT[mTier]};
+            OVERLAYS_ENERGY_OUT[mTier]
+        };
     }
 
     @Override
     public ITexture[] getBack(byte aColor) {
-        return new ITexture[]{
+        return new ITexture[] {
             super.getBack(aColor)[0],
             TextureFactory.of(MACHINE_CASING_MAGIC_FRONT),
-            TextureFactory.builder().addIcon(MACHINE_CASING_MAGIC_FRONT_GLOW).glow().build()};
+            TextureFactory.builder()
+                    .addIcon(MACHINE_CASING_MAGIC_FRONT_GLOW)
+                    .glow()
+                    .build()
+        };
     }
 
     @Override
     public ITexture[] getBottom(byte aColor) {
-        return new ITexture[]{
+        return new ITexture[] {
             super.getBottom(aColor)[0],
             TextureFactory.of(MACHINE_CASING_MAGIC),
-            TextureFactory.builder().addIcon(MACHINE_CASING_MAGIC_GLOW).glow().build()};
+            TextureFactory.builder().addIcon(MACHINE_CASING_MAGIC_GLOW).glow().build()
+        };
     }
 
     @Override
     public ITexture[] getTop(byte aColor) {
-        return new ITexture[]{
-            super.getTop(aColor)[0],
-            TextureFactory.of(MACHINE_CASING_DRAGONEGG)};
+        return new ITexture[] {super.getTop(aColor)[0], TextureFactory.of(MACHINE_CASING_DRAGONEGG)};
     }
 
     @Override
     public ITexture[] getSides(byte aColor) {
-        return new ITexture[]{
+        return new ITexture[] {
             super.getSides(aColor)[0],
             TextureFactory.of(MACHINE_CASING_MAGIC),
-            TextureFactory.builder().addIcon(MACHINE_CASING_MAGIC_GLOW).glow().build()};
+            TextureFactory.builder().addIcon(MACHINE_CASING_MAGIC_GLOW).glow().build()
+        };
     }
 
     @Override
     public ITexture[] getFrontActive(byte aColor) {
-        return new ITexture[]{
+        return new ITexture[] {
             super.getFrontActive(aColor)[0],
             TextureFactory.of(MACHINE_CASING_MAGIC_ACTIVE),
-            TextureFactory.builder().addIcon(MACHINE_CASING_MAGIC_ACTIVE_GLOW).glow().build(),
-            OVERLAYS_ENERGY_OUT[mTier]};
+            TextureFactory.builder()
+                    .addIcon(MACHINE_CASING_MAGIC_ACTIVE_GLOW)
+                    .glow()
+                    .build(),
+            OVERLAYS_ENERGY_OUT[mTier]
+        };
     }
 
     @Override
     public ITexture[] getBackActive(byte aColor) {
-        return new ITexture[]{
+        return new ITexture[] {
             super.getBackActive(aColor)[0],
             TextureFactory.of(MACHINE_CASING_MAGIC_FRONT_ACTIVE),
-            TextureFactory.builder().addIcon(MACHINE_CASING_MAGIC_FRONT_ACTIVE_GLOW).glow().build()};
+            TextureFactory.builder()
+                    .addIcon(MACHINE_CASING_MAGIC_FRONT_ACTIVE_GLOW)
+                    .glow()
+                    .build()
+        };
     }
 
     @Override
     public ITexture[] getBottomActive(byte aColor) {
-        return new ITexture[]{
+        return new ITexture[] {
             super.getBottomActive(aColor)[0],
             TextureFactory.of(MACHINE_CASING_MAGIC_ACTIVE),
-            TextureFactory.builder().addIcon(MACHINE_CASING_MAGIC_ACTIVE_GLOW).glow().build()};
+            TextureFactory.builder()
+                    .addIcon(MACHINE_CASING_MAGIC_ACTIVE_GLOW)
+                    .glow()
+                    .build()
+        };
     }
 
     @Override
     public ITexture[] getTopActive(byte aColor) {
-        return new ITexture[]{
+        return new ITexture[] {
             super.getTopActive(aColor)[0],
             TextureFactory.of(MACHINE_CASING_DRAGONEGG),
-            TextureFactory.builder().addIcon(MACHINE_CASING_DRAGONEGG_GLOW).glow().build()
+            TextureFactory.builder()
+                    .addIcon(MACHINE_CASING_DRAGONEGG_GLOW)
+                    .glow()
+                    .build()
         };
     }
 
     @Override
     public ITexture[] getSidesActive(byte aColor) {
-        return new ITexture[]{
+        return new ITexture[] {
             super.getSidesActive(aColor)[0],
             TextureFactory.of(MACHINE_CASING_MAGIC_ACTIVE),
-            TextureFactory.builder().addIcon(MACHINE_CASING_MAGIC_ACTIVE_GLOW).glow().build()};
+            TextureFactory.builder()
+                    .addIcon(MACHINE_CASING_MAGIC_ACTIVE_GLOW)
+                    .glow()
+                    .build()
+        };
     }
 
     @Override
@@ -331,7 +373,8 @@ public class GT_MetaTileEntity_MagicalEnergyAbsorber extends GT_MetaTileEntity_B
                 mNextGenerateTickRate = 20;
             }
             aBaseMetaTileEntity.increaseStoredEnergyUnits(tGeneratedEU, true);
-            aBaseMetaTileEntity.setActive(aBaseMetaTileEntity.isAllowedToWork() && aBaseMetaTileEntity.getUniversalEnergyStored() >= maxEUOutput() + getMinimumStoredEU());
+            aBaseMetaTileEntity.setActive(aBaseMetaTileEntity.isAllowedToWork()
+                    && aBaseMetaTileEntity.getUniversalEnergyStored() >= maxEUOutput() + getMinimumStoredEU());
         }
     }
 
@@ -355,8 +398,8 @@ public class GT_MetaTileEntity_MagicalEnergyAbsorber extends GT_MetaTileEntity_B
                 final double oZ = aBaseMetaTileEntity.getZCoord() + 8D / 16D;
 
                 final ParticleEventBuilder particleEventBuilder = new ParticleEventBuilder()
-                    .setWorld(getBaseMetaTileEntity().getWorld())
-                    .setIdentifier(ParticleFX.PORTAL);
+                        .setWorld(getBaseMetaTileEntity().getWorld())
+                        .setIdentifier(ParticleFX.PORTAL);
 
                 for (int i = 0; i < 9; i++) {
                     final double dX = (XSTR_INSTANCE.nextFloat() - 0.5D) / 2D;
@@ -372,7 +415,10 @@ public class GT_MetaTileEntity_MagicalEnergyAbsorber extends GT_MetaTileEntity_B
                     final double mY = -(dXZ * dY) / 4D;
                     final double mZ = dZ * 4D;
 
-                    particleEventBuilder.setMotion(mX, mY, mZ).setPosition(x, y, z).run();
+                    particleEventBuilder
+                            .setMotion(mX, mY, mZ)
+                            .setPosition(x, y, z)
+                            .run();
                 }
             }
         }
@@ -452,8 +498,9 @@ public class GT_MetaTileEntity_MagicalEnergyAbsorber extends GT_MetaTileEntity_B
         }
 
         // Only consume input when it can store EU and push output
-        if ((getBaseMetaTileEntity().getStoredEU() + tEU) < getBaseMetaTileEntity().getEUCapacity()
-            && getBaseMetaTileEntity().addStackToSlot(getOutputSlot(), tOutputStack)) {
+        if ((getBaseMetaTileEntity().getStoredEU() + tEU)
+                        < getBaseMetaTileEntity().getEUCapacity()
+                && getBaseMetaTileEntity().addStackToSlot(getOutputSlot(), tOutputStack)) {
             decrStackSize(getInputSlot(), 1);
         } else {
             tEU = 0;
@@ -470,11 +517,11 @@ public class GT_MetaTileEntity_MagicalEnergyAbsorber extends GT_MetaTileEntity_B
         if (!hasEgg()) return 0;
         if (!sAllowMultipleEggs) {
             if (sActiveSiphon != null
-                && sActiveSiphon != this
-                && sActiveSiphon.getBaseMetaTileEntity() != null
-                && !sActiveSiphon.getBaseMetaTileEntity().isInvalidTileEntity()
-                && sActiveSiphon.isChunkLoaded()
-                && sActiveSiphon.hasEgg()) {
+                    && sActiveSiphon != this
+                    && sActiveSiphon.getBaseMetaTileEntity() != null
+                    && !sActiveSiphon.getBaseMetaTileEntity().isInvalidTileEntity()
+                    && sActiveSiphon.isChunkLoaded()
+                    && sActiveSiphon.hasEgg()) {
                 getBaseMetaTileEntity().doExplosion(Integer.MAX_VALUE);
             } else {
                 setActiveSiphon(this);
@@ -528,7 +575,8 @@ public class GT_MetaTileEntity_MagicalEnergyAbsorber extends GT_MetaTileEntity_B
 
         long tEU = 0;
 
-        long tEUtoGen = getBaseMetaTileEntity().getEUCapacity() - getBaseMetaTileEntity().getUniversalEnergyStored();
+        long tEUtoGen = getBaseMetaTileEntity().getEUCapacity()
+                - getBaseMetaTileEntity().getUniversalEnergyStored();
         List<Aspect> mAvailableEssentiaAspects = mMagicalEnergyBB.getAvailableAspects();
 
         // try to drain 1 of whatever aspect available in containers within RANGE
@@ -536,7 +584,11 @@ public class GT_MetaTileEntity_MagicalEnergyAbsorber extends GT_MetaTileEntity_B
             Aspect aspect = mAvailableEssentiaAspects.get(i);
             long tAspectEU = ((long) sAspectsEnergy.get(aspect) * getEfficiency()) / 100;
             if (tAspectEU <= tEUtoGen
-                && AspectSourceHelper.drainEssentia((TileEntity) getBaseMetaTileEntity(), aspect, ForgeDirection.UNKNOWN, mMagicalEnergyBB.getRange())) {
+                    && AspectSourceHelper.drainEssentia(
+                            (TileEntity) getBaseMetaTileEntity(),
+                            aspect,
+                            ForgeDirection.UNKNOWN,
+                            mMagicalEnergyBB.getRange())) {
                 tEUtoGen -= tAspectEU;
                 tEU += tAspectEU;
             }
@@ -657,15 +709,14 @@ public class GT_MetaTileEntity_MagicalEnergyAbsorber extends GT_MetaTileEntity_B
             double tX = tBaseMetaTileEntity.getXCoord();
             double tY = tBaseMetaTileEntity.getYCoord();
             double tZ = tBaseMetaTileEntity.getZCoord();
-            return AxisAlignedBB.getBoundingBox(tX - tRange, tY - tRange, tZ - tRange,
-                    tX + tRange, tY + tRange, tZ + tRange);
+            return AxisAlignedBB.getBoundingBox(
+                    tX - tRange, tY - tRange, tZ - tRange, tX + tRange, tY + tRange, tZ + tRange);
         }
 
         private void scanLivingCrystals() {
             World tWorld = mAbsorber.getBaseMetaTileEntity().getWorld();
             mLivingCrystalIDs.clear();
-            for (Object o : tWorld.getEntitiesWithinAABB(EntityEnderCrystal.class,
-                    getAxisAlignedBB())) {
+            for (Object o : tWorld.getEntitiesWithinAABB(EntityEnderCrystal.class, getAxisAlignedBB())) {
                 if (((EntityEnderCrystal) o).isEntityAlive()) {
                     mLivingCrystalIDs.add(((EntityEnderCrystal) o).getPersistentID());
                 }
@@ -678,10 +729,10 @@ public class GT_MetaTileEntity_MagicalEnergyAbsorber extends GT_MetaTileEntity_B
             if (tBaseMetaTileEntity.isInvalidTileEntity()) return;
             int tRange = getRange();
             int tY = tBaseMetaTileEntity.getYCoord();
-            int tMaxY = tBaseMetaTileEntity.getWorld().getHeight()-1;
+            int tMaxY = tBaseMetaTileEntity.getWorld().getHeight() - 1;
             // Make sure relative Y range stays between 0 and world max Y
             int rYMin = (tY - tRange >= 0) ? -tRange : -(tY);
-            int rYMax = (((tY + tRange) <= tMaxY)? tRange : tMaxY - tY);
+            int rYMax = (((tY + tRange) <= tMaxY) ? tRange : tMaxY - tY);
             mAvailableAspects.clear();
             for (int rX = -tRange; rX <= tRange; rX++) {
                 for (int rZ = -tRange; rZ <= tRange; rZ++) {
diff --git a/src/main/java/gregtech/common/tileentities/generators/GT_MetaTileEntity_NaquadahReactor.java b/src/main/java/gregtech/common/tileentities/generators/GT_MetaTileEntity_NaquadahReactor.java
index 0a99a4af05..6ca6da874f 100644
--- a/src/main/java/gregtech/common/tileentities/generators/GT_MetaTileEntity_NaquadahReactor.java
+++ b/src/main/java/gregtech/common/tileentities/generators/GT_MetaTileEntity_NaquadahReactor.java
@@ -1,5 +1,7 @@
 package gregtech.common.tileentities.generators;
 
+import static gregtech.api.enums.Textures.BlockIcons.*;
+
 import gregtech.api.GregTech_API;
 import gregtech.api.enums.ConfigCategories;
 import gregtech.api.interfaces.ITexture;
@@ -9,13 +11,12 @@ import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_BasicGenera
 import gregtech.api.render.TextureFactory;
 import gregtech.api.util.GT_Recipe;
 
-import static gregtech.api.enums.Textures.BlockIcons.*;
-
 public class GT_MetaTileEntity_NaquadahReactor extends GT_MetaTileEntity_BasicGenerator {
 
     private int mEfficiency;
 
-    public GT_MetaTileEntity_NaquadahReactor(int aID, String aName, String[] aDescription, String aNameRegional, int aTier) {
+    public GT_MetaTileEntity_NaquadahReactor(
+            int aID, String aName, String[] aDescription, String aNameRegional, int aTier) {
         super(aID, aName, aNameRegional, aTier, aDescription);
         if (aTier > 8 || aTier < 4) {
             new Exception("Tier without Recipe Map!").printStackTrace();
@@ -33,7 +34,9 @@ public class GT_MetaTileEntity_NaquadahReactor extends GT_MetaTileEntity_BasicGe
 
     @Override
     public boolean isOutputFacing(byte aSide) {
-        return (aSide > 1) && (aSide != getBaseMetaTileEntity().getFrontFacing()) && (aSide != getBaseMetaTileEntity().getBackFacing());
+        return (aSide > 1)
+                && (aSide != getBaseMetaTileEntity().getFrontFacing())
+                && (aSide != getBaseMetaTileEntity().getBackFacing());
     }
 
     @Override
@@ -69,7 +72,6 @@ public class GT_MetaTileEntity_NaquadahReactor extends GT_MetaTileEntity_BasicGe
                 ret = null;
                 break;
             }
-
         }
         return ret;
     }
@@ -89,82 +91,133 @@ public class GT_MetaTileEntity_NaquadahReactor extends GT_MetaTileEntity_BasicGe
     }
 
     public int onConfigLoad() {
-        return mEfficiency = GregTech_API.sMachineFile.get(ConfigCategories.machineconfig, "SolidNaquadah.efficiency.tier." + mTier, getBaseEff());
+        return mEfficiency = GregTech_API.sMachineFile.get(
+                ConfigCategories.machineconfig, "SolidNaquadah.efficiency.tier." + mTier, getBaseEff());
     }
 
     @Override
     public ITexture[] getFront(byte aColor) {
-        return new ITexture[]{super.getFront(aColor)[0], TextureFactory.of(
-                TextureFactory.of(NAQUADAH_REACTOR_SOLID_FRONT),
-                TextureFactory.builder().addIcon(NAQUADAH_REACTOR_SOLID_FRONT_GLOW).glow().build())};
+        return new ITexture[] {
+            super.getFront(aColor)[0],
+            TextureFactory.of(
+                    TextureFactory.of(NAQUADAH_REACTOR_SOLID_FRONT),
+                    TextureFactory.builder()
+                            .addIcon(NAQUADAH_REACTOR_SOLID_FRONT_GLOW)
+                            .glow()
+                            .build())
+        };
     }
 
     @Override
     public ITexture[] getBack(byte aColor) {
-        return new ITexture[]{super.getBack(aColor)[0], TextureFactory.of(
-                TextureFactory.of(NAQUADAH_REACTOR_SOLID_BACK),
-                TextureFactory.builder().addIcon(NAQUADAH_REACTOR_SOLID_BACK_GLOW).glow().build())};
+        return new ITexture[] {
+            super.getBack(aColor)[0],
+            TextureFactory.of(
+                    TextureFactory.of(NAQUADAH_REACTOR_SOLID_BACK),
+                    TextureFactory.builder()
+                            .addIcon(NAQUADAH_REACTOR_SOLID_BACK_GLOW)
+                            .glow()
+                            .build())
+        };
     }
 
     @Override
     public ITexture[] getBottom(byte aColor) {
-        return new ITexture[]{super.getBottom(aColor)[0], TextureFactory.of(
-                TextureFactory.of(NAQUADAH_REACTOR_SOLID_BOTTOM),
-                TextureFactory.builder().addIcon(NAQUADAH_REACTOR_SOLID_BOTTOM_GLOW).glow().build())};
+        return new ITexture[] {
+            super.getBottom(aColor)[0],
+            TextureFactory.of(
+                    TextureFactory.of(NAQUADAH_REACTOR_SOLID_BOTTOM),
+                    TextureFactory.builder()
+                            .addIcon(NAQUADAH_REACTOR_SOLID_BOTTOM_GLOW)
+                            .glow()
+                            .build())
+        };
     }
 
     @Override
     public ITexture[] getTop(byte aColor) {
-        return new ITexture[]{super.getTop(aColor)[0], TextureFactory.of(
-                TextureFactory.of(NAQUADAH_REACTOR_SOLID_TOP),
-                TextureFactory.builder().addIcon(NAQUADAH_REACTOR_SOLID_TOP_GLOW).glow().build())};
+        return new ITexture[] {
+            super.getTop(aColor)[0],
+            TextureFactory.of(
+                    TextureFactory.of(NAQUADAH_REACTOR_SOLID_TOP),
+                    TextureFactory.builder()
+                            .addIcon(NAQUADAH_REACTOR_SOLID_TOP_GLOW)
+                            .glow()
+                            .build())
+        };
     }
 
     @Override
     public ITexture[] getSides(byte aColor) {
-        return new ITexture[]{super.getSides(aColor)[0], TextureFactory.of(
-                TextureFactory.of(NAQUADAH_REACTOR_SOLID_SIDE),
-                TextureFactory.builder().addIcon(NAQUADAH_REACTOR_SOLID_SIDE_GLOW).glow().build())};
+        return new ITexture[] {
+            super.getSides(aColor)[0],
+            TextureFactory.of(
+                    TextureFactory.of(NAQUADAH_REACTOR_SOLID_SIDE),
+                    TextureFactory.builder()
+                            .addIcon(NAQUADAH_REACTOR_SOLID_SIDE_GLOW)
+                            .glow()
+                            .build())
+        };
     }
 
     @Override
     public ITexture[] getFrontActive(byte aColor) {
-        return new ITexture[]{
-                super.getFrontActive(aColor)[0],
-                TextureFactory.of(NAQUADAH_REACTOR_SOLID_FRONT_ACTIVE),
-                TextureFactory.builder().addIcon(NAQUADAH_REACTOR_SOLID_FRONT_ACTIVE_GLOW).glow().build()};
+        return new ITexture[] {
+            super.getFrontActive(aColor)[0],
+            TextureFactory.of(NAQUADAH_REACTOR_SOLID_FRONT_ACTIVE),
+            TextureFactory.builder()
+                    .addIcon(NAQUADAH_REACTOR_SOLID_FRONT_ACTIVE_GLOW)
+                    .glow()
+                    .build()
+        };
     }
 
     @Override
     public ITexture[] getBackActive(byte aColor) {
-        return new ITexture[]{
-                super.getBackActive(aColor)[0],
-                TextureFactory.of(NAQUADAH_REACTOR_SOLID_BACK_ACTIVE),
-                TextureFactory.builder().addIcon(NAQUADAH_REACTOR_SOLID_BACK_ACTIVE_GLOW).glow().build()};
+        return new ITexture[] {
+            super.getBackActive(aColor)[0],
+            TextureFactory.of(NAQUADAH_REACTOR_SOLID_BACK_ACTIVE),
+            TextureFactory.builder()
+                    .addIcon(NAQUADAH_REACTOR_SOLID_BACK_ACTIVE_GLOW)
+                    .glow()
+                    .build()
+        };
     }
 
     @Override
     public ITexture[] getBottomActive(byte aColor) {
-        return new ITexture[]{
-                super.getBottomActive(aColor)[0],
-                TextureFactory.of(NAQUADAH_REACTOR_SOLID_BOTTOM_ACTIVE),
-                TextureFactory.builder().addIcon(NAQUADAH_REACTOR_SOLID_BOTTOM_ACTIVE_GLOW).glow().build()};
+        return new ITexture[] {
+            super.getBottomActive(aColor)[0],
+            TextureFactory.of(NAQUADAH_REACTOR_SOLID_BOTTOM_ACTIVE),
+            TextureFactory.builder()
+                    .addIcon(NAQUADAH_REACTOR_SOLID_BOTTOM_ACTIVE_GLOW)
+                    .glow()
+                    .build()
+        };
     }
 
     @Override
     public ITexture[] getTopActive(byte aColor) {
-        return new ITexture[]{
-                super.getTopActive(aColor)[0],
-                TextureFactory.of(NAQUADAH_REACTOR_SOLID_TOP_ACTIVE),
-                TextureFactory.builder().addIcon(NAQUADAH_REACTOR_SOLID_TOP_ACTIVE_GLOW).glow().build()};
+        return new ITexture[] {
+            super.getTopActive(aColor)[0],
+            TextureFactory.of(NAQUADAH_REACTOR_SOLID_TOP_ACTIVE),
+            TextureFactory.builder()
+                    .addIcon(NAQUADAH_REACTOR_SOLID_TOP_ACTIVE_GLOW)
+                    .glow()
+                    .build()
+        };
     }
 
     @Override
     public ITexture[] getSidesActive(byte aColor) {
-        return new ITexture[]{
-                super.getSidesActive(aColor)[0],
-                TextureFactory.of(NAQUADAH_REACTOR_SOLID_SIDE_ACTIVE),
-                TextureFactory.builder().addIcon(NAQUADAH_REACTOR_SOLID_SIDE_ACTIVE_GLOW).glow().build()};
+        return new ITexture[] {
+            super.getSidesActive(aColor)[0],
+            TextureFactory.of(NAQUADAH_REACTOR_SOLID_SIDE_ACTIVE),
+            TextureFactory.builder()
+                    .addIcon(NAQUADAH_REACTOR_SOLID_SIDE_ACTIVE_GLOW)
+                    .glow()
+                    .build()
+        };
     }
 
     @Override
diff --git a/src/main/java/gregtech/common/tileentities/generators/GT_MetaTileEntity_PlasmaGenerator.java b/src/main/java/gregtech/common/tileentities/generators/GT_MetaTileEntity_PlasmaGenerator.java
index 4ab048a0f7..4e0b428fa4 100644
--- a/src/main/java/gregtech/common/tileentities/generators/GT_MetaTileEntity_PlasmaGenerator.java
+++ b/src/main/java/gregtech/common/tileentities/generators/GT_MetaTileEntity_PlasmaGenerator.java
@@ -1,5 +1,10 @@
 package gregtech.common.tileentities.generators;
 
+import static gregtech.api.enums.Textures.BlockIcons.MACHINE_CASING_FUSION_GLASS;
+import static gregtech.api.enums.Textures.BlockIcons.MACHINE_CASING_FUSION_GLASS_YELLOW;
+import static gregtech.api.enums.Textures.BlockIcons.MACHINE_CASING_FUSION_GLASS_YELLOW_GLOW;
+import static gregtech.api.enums.Textures.BlockIcons.OVERLAYS_ENERGY_OUT;
+
 import gregtech.api.GregTech_API;
 import gregtech.api.enums.ConfigCategories;
 import gregtech.api.interfaces.ITexture;
@@ -9,11 +14,6 @@ import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_BasicGenera
 import gregtech.api.render.TextureFactory;
 import gregtech.api.util.GT_Recipe;
 
-import static gregtech.api.enums.Textures.BlockIcons.MACHINE_CASING_FUSION_GLASS;
-import static gregtech.api.enums.Textures.BlockIcons.MACHINE_CASING_FUSION_GLASS_YELLOW;
-import static gregtech.api.enums.Textures.BlockIcons.MACHINE_CASING_FUSION_GLASS_YELLOW_GLOW;
-import static gregtech.api.enums.Textures.BlockIcons.OVERLAYS_ENERGY_OUT;
-
 public class GT_MetaTileEntity_PlasmaGenerator extends GT_MetaTileEntity_BasicGenerator {
 
     public int mEfficiency;
@@ -35,71 +35,90 @@ public class GT_MetaTileEntity_PlasmaGenerator extends GT_MetaTileEntity_BasicGe
 
     @Override
     public ITexture[] getFront(byte aColor) {
-        return new ITexture[]{
-                super.getFront(aColor)[0],
-                TextureFactory.of(MACHINE_CASING_FUSION_GLASS),
-                OVERLAYS_ENERGY_OUT[mTier]};
+        return new ITexture[] {
+            super.getFront(aColor)[0], TextureFactory.of(MACHINE_CASING_FUSION_GLASS), OVERLAYS_ENERGY_OUT[mTier]
+        };
     }
 
     @Override
     public ITexture[] getBack(byte aColor) {
-        return new ITexture[]{super.getBack(aColor)[0], TextureFactory.of(MACHINE_CASING_FUSION_GLASS)};
+        return new ITexture[] {super.getBack(aColor)[0], TextureFactory.of(MACHINE_CASING_FUSION_GLASS)};
     }
 
     @Override
     public ITexture[] getBottom(byte aColor) {
-        return new ITexture[]{super.getBottom(aColor)[0], TextureFactory.of(MACHINE_CASING_FUSION_GLASS)};
+        return new ITexture[] {super.getBottom(aColor)[0], TextureFactory.of(MACHINE_CASING_FUSION_GLASS)};
     }
 
     @Override
     public ITexture[] getTop(byte aColor) {
-        return new ITexture[]{super.getTop(aColor)[0], TextureFactory.of(MACHINE_CASING_FUSION_GLASS)};
+        return new ITexture[] {super.getTop(aColor)[0], TextureFactory.of(MACHINE_CASING_FUSION_GLASS)};
     }
 
     @Override
     public ITexture[] getSides(byte aColor) {
-        return new ITexture[]{super.getSides(aColor)[0], TextureFactory.of(MACHINE_CASING_FUSION_GLASS)};
+        return new ITexture[] {super.getSides(aColor)[0], TextureFactory.of(MACHINE_CASING_FUSION_GLASS)};
     }
 
     @Override
     public ITexture[] getFrontActive(byte aColor) {
-        return new ITexture[]{
-                super.getFrontActive(aColor)[0],
-                TextureFactory.of(MACHINE_CASING_FUSION_GLASS_YELLOW),
-                TextureFactory.builder().addIcon(MACHINE_CASING_FUSION_GLASS_YELLOW_GLOW).glow().build(),
-                OVERLAYS_ENERGY_OUT[mTier]};
+        return new ITexture[] {
+            super.getFrontActive(aColor)[0],
+            TextureFactory.of(MACHINE_CASING_FUSION_GLASS_YELLOW),
+            TextureFactory.builder()
+                    .addIcon(MACHINE_CASING_FUSION_GLASS_YELLOW_GLOW)
+                    .glow()
+                    .build(),
+            OVERLAYS_ENERGY_OUT[mTier]
+        };
     }
 
     @Override
     public ITexture[] getBackActive(byte aColor) {
-        return new ITexture[]{
-                super.getBackActive(aColor)[0],
-                TextureFactory.of(MACHINE_CASING_FUSION_GLASS_YELLOW),
-                TextureFactory.builder().addIcon(MACHINE_CASING_FUSION_GLASS_YELLOW_GLOW).glow().build()};
+        return new ITexture[] {
+            super.getBackActive(aColor)[0],
+            TextureFactory.of(MACHINE_CASING_FUSION_GLASS_YELLOW),
+            TextureFactory.builder()
+                    .addIcon(MACHINE_CASING_FUSION_GLASS_YELLOW_GLOW)
+                    .glow()
+                    .build()
+        };
     }
 
     @Override
     public ITexture[] getBottomActive(byte aColor) {
-        return new ITexture[]{
-                super.getBottomActive(aColor)[0],
-                TextureFactory.of(MACHINE_CASING_FUSION_GLASS_YELLOW),
-                TextureFactory.builder().addIcon(MACHINE_CASING_FUSION_GLASS_YELLOW_GLOW).glow().build()};
+        return new ITexture[] {
+            super.getBottomActive(aColor)[0],
+            TextureFactory.of(MACHINE_CASING_FUSION_GLASS_YELLOW),
+            TextureFactory.builder()
+                    .addIcon(MACHINE_CASING_FUSION_GLASS_YELLOW_GLOW)
+                    .glow()
+                    .build()
+        };
     }
 
     @Override
     public ITexture[] getTopActive(byte aColor) {
-        return new ITexture[]{
-                super.getTopActive(aColor)[0],
-                TextureFactory.of(MACHINE_CASING_FUSION_GLASS_YELLOW),
-                TextureFactory.builder().addIcon(MACHINE_CASING_FUSION_GLASS_YELLOW_GLOW).glow().build()};
+        return new ITexture[] {
+            super.getTopActive(aColor)[0],
+            TextureFactory.of(MACHINE_CASING_FUSION_GLASS_YELLOW),
+            TextureFactory.builder()
+                    .addIcon(MACHINE_CASING_FUSION_GLASS_YELLOW_GLOW)
+                    .glow()
+                    .build()
+        };
     }
 
     @Override
     public ITexture[] getSidesActive(byte aColor) {
-        return new ITexture[]{
-                super.getSidesActive(aColor)[0],
-                TextureFactory.of(MACHINE_CASING_FUSION_GLASS_YELLOW),
-                TextureFactory.builder().addIcon(MACHINE_CASING_FUSION_GLASS_YELLOW_GLOW).glow().build()};
+        return new ITexture[] {
+            super.getSidesActive(aColor)[0],
+            TextureFactory.of(MACHINE_CASING_FUSION_GLASS_YELLOW),
+            TextureFactory.builder()
+                    .addIcon(MACHINE_CASING_FUSION_GLASS_YELLOW_GLOW)
+                    .glow()
+                    .build()
+        };
     }
 
     @Override
@@ -128,11 +147,14 @@ public class GT_MetaTileEntity_PlasmaGenerator extends GT_MetaTileEntity_BasicGe
     }
 
     public void onConfigLoad() {
-        this.mEfficiency = GregTech_API.sMachineFile.get(ConfigCategories.machineconfig, "PlasmaGenerator.efficiency.tier." + this.mTier, Math.max(10, 10 + Math.min(90, this.mTier * 10)));
+        this.mEfficiency = GregTech_API.sMachineFile.get(
+                ConfigCategories.machineconfig,
+                "PlasmaGenerator.efficiency.tier." + this.mTier,
+                Math.max(10, 10 + Math.min(90, this.mTier * 10)));
     }
 
     @Override
-	public int getPollution() {
-		return 0;
-	}
+    public int getPollution() {
+        return 0;
+    }
 }
diff --git a/src/main/java/gregtech/common/tileentities/generators/GT_MetaTileEntity_SteamTurbine.java b/src/main/java/gregtech/common/tileentities/generators/GT_MetaTileEntity_SteamTurbine.java
index d7b3f03fde..bec1b90ad1 100644
--- a/src/main/java/gregtech/common/tileentities/generators/GT_MetaTileEntity_SteamTurbine.java
+++ b/src/main/java/gregtech/common/tileentities/generators/GT_MetaTileEntity_SteamTurbine.java
@@ -1,5 +1,7 @@
 package gregtech.common.tileentities.generators;
 
+import static gregtech.api.enums.Textures.BlockIcons.*;
+
 import gregtech.api.GregTech_API;
 import gregtech.api.enums.ConfigCategories;
 import gregtech.api.interfaces.ITexture;
@@ -11,16 +13,13 @@ import gregtech.api.util.GT_ModHandler;
 import gregtech.api.util.GT_Recipe;
 import net.minecraftforge.fluids.FluidStack;
 
-import static gregtech.api.enums.Textures.BlockIcons.*;
-
 public class GT_MetaTileEntity_SteamTurbine extends GT_MetaTileEntity_BasicGenerator {
 
     public int mEfficiency;
 
     public GT_MetaTileEntity_SteamTurbine(int aID, String aName, String aNameRegional, int aTier) {
-        super(aID, aName, aNameRegional, aTier, new String[]{
-                "Converts Steam into EU",
-                "Base rate: 2L of Steam -> 1 EU"});
+        super(aID, aName, aNameRegional, aTier, new String[] {"Converts Steam into EU", "Base rate: 2L of Steam -> 1 EU"
+        });
         onConfigLoad();
     }
 
@@ -54,7 +53,8 @@ public class GT_MetaTileEntity_SteamTurbine extends GT_MetaTileEntity_BasicGener
         String[] desc = new String[mDescriptionArray.length + 2];
         System.arraycopy(mDescriptionArray, 0, desc, 0, mDescriptionArray.length);
         desc[mDescriptionArray.length] = "Fuel Efficiency: " + (600 / getEfficiency()) + "%";
-        desc[mDescriptionArray.length + 1] = String.format("Consumes up to %sL of Steam per second",
+        desc[mDescriptionArray.length + 1] = String.format(
+                "Consumes up to %sL of Steam per second",
                 (int) (4000 * (8 * Math.pow(4, mTier) + Math.pow(2, mTier)) / (600 / getEfficiency())));
         return desc;
     }
@@ -65,7 +65,8 @@ public class GT_MetaTileEntity_SteamTurbine extends GT_MetaTileEntity_BasicGener
     }
 
     public void onConfigLoad() {
-        this.mEfficiency = GregTech_API.sMachineFile.get(ConfigCategories.machineconfig, "SteamTurbine.efficiency.tier." + this.mTier, 6 + this.mTier);
+        this.mEfficiency = GregTech_API.sMachineFile.get(
+                ConfigCategories.machineconfig, "SteamTurbine.efficiency.tier." + this.mTier, 6 + this.mTier);
     }
 
     @Override
@@ -86,74 +87,134 @@ public class GT_MetaTileEntity_SteamTurbine extends GT_MetaTileEntity_BasicGener
 
     @Override
     public ITexture[] getFront(byte aColor) {
-        return new ITexture[]{super.getFront(aColor)[0], TextureFactory.of(
-                TextureFactory.of(STEAM_TURBINE_FRONT),
-                TextureFactory.builder().addIcon(STEAM_TURBINE_FRONT_GLOW).glow().build()),
-                OVERLAYS_ENERGY_OUT[this.mTier]};
+        return new ITexture[] {
+            super.getFront(aColor)[0],
+            TextureFactory.of(
+                    TextureFactory.of(STEAM_TURBINE_FRONT),
+                    TextureFactory.builder()
+                            .addIcon(STEAM_TURBINE_FRONT_GLOW)
+                            .glow()
+                            .build()),
+            OVERLAYS_ENERGY_OUT[this.mTier]
+        };
     }
 
     @Override
     public ITexture[] getBack(byte aColor) {
-        return new ITexture[]{super.getBack(aColor)[0], TextureFactory.of(
-                TextureFactory.of(STEAM_TURBINE_BACK),
-                TextureFactory.builder().addIcon(STEAM_TURBINE_BACK_GLOW).glow().build())};
+        return new ITexture[] {
+            super.getBack(aColor)[0],
+            TextureFactory.of(
+                    TextureFactory.of(STEAM_TURBINE_BACK),
+                    TextureFactory.builder()
+                            .addIcon(STEAM_TURBINE_BACK_GLOW)
+                            .glow()
+                            .build())
+        };
     }
 
     @Override
     public ITexture[] getBottom(byte aColor) {
-        return new ITexture[]{super.getBottom(aColor)[0], TextureFactory.of(
-                TextureFactory.of(STEAM_TURBINE_BOTTOM),
-                TextureFactory.builder().addIcon(STEAM_TURBINE_BOTTOM_GLOW).glow().build())};
+        return new ITexture[] {
+            super.getBottom(aColor)[0],
+            TextureFactory.of(
+                    TextureFactory.of(STEAM_TURBINE_BOTTOM),
+                    TextureFactory.builder()
+                            .addIcon(STEAM_TURBINE_BOTTOM_GLOW)
+                            .glow()
+                            .build())
+        };
     }
 
     @Override
     public ITexture[] getTop(byte aColor) {
-        return new ITexture[]{super.getTop(aColor)[0], TextureFactory.of(
-                TextureFactory.of(STEAM_TURBINE_TOP),
-                TextureFactory.builder().addIcon(STEAM_TURBINE_TOP_GLOW).glow().build())};
+        return new ITexture[] {
+            super.getTop(aColor)[0],
+            TextureFactory.of(
+                    TextureFactory.of(STEAM_TURBINE_TOP),
+                    TextureFactory.builder()
+                            .addIcon(STEAM_TURBINE_TOP_GLOW)
+                            .glow()
+                            .build())
+        };
     }
 
     @Override
     public ITexture[] getSides(byte aColor) {
-        return new ITexture[]{super.getSides(aColor)[0], TextureFactory.of(
-                TextureFactory.of(STEAM_TURBINE_SIDE),
-                TextureFactory.builder().addIcon(STEAM_TURBINE_SIDE_GLOW).glow().build())};
+        return new ITexture[] {
+            super.getSides(aColor)[0],
+            TextureFactory.of(
+                    TextureFactory.of(STEAM_TURBINE_SIDE),
+                    TextureFactory.builder()
+                            .addIcon(STEAM_TURBINE_SIDE_GLOW)
+                            .glow()
+                            .build())
+        };
     }
 
     @Override
     public ITexture[] getFrontActive(byte aColor) {
-        return new ITexture[]{super.getFrontActive(aColor)[0], TextureFactory.of(
-                TextureFactory.of(STEAM_TURBINE_FRONT_ACTIVE),
-                TextureFactory.builder().addIcon(STEAM_TURBINE_FRONT_ACTIVE_GLOW).glow().build()),
-                OVERLAYS_ENERGY_OUT[this.mTier]};
+        return new ITexture[] {
+            super.getFrontActive(aColor)[0],
+            TextureFactory.of(
+                    TextureFactory.of(STEAM_TURBINE_FRONT_ACTIVE),
+                    TextureFactory.builder()
+                            .addIcon(STEAM_TURBINE_FRONT_ACTIVE_GLOW)
+                            .glow()
+                            .build()),
+            OVERLAYS_ENERGY_OUT[this.mTier]
+        };
     }
 
     @Override
     public ITexture[] getBackActive(byte aColor) {
-        return new ITexture[]{super.getBackActive(aColor)[0], TextureFactory.of(
-                TextureFactory.of(STEAM_TURBINE_BACK_ACTIVE),
-                TextureFactory.builder().addIcon(STEAM_TURBINE_BACK_ACTIVE_GLOW).glow().build())};
+        return new ITexture[] {
+            super.getBackActive(aColor)[0],
+            TextureFactory.of(
+                    TextureFactory.of(STEAM_TURBINE_BACK_ACTIVE),
+                    TextureFactory.builder()
+                            .addIcon(STEAM_TURBINE_BACK_ACTIVE_GLOW)
+                            .glow()
+                            .build())
+        };
     }
 
     @Override
     public ITexture[] getBottomActive(byte aColor) {
-        return new ITexture[]{super.getBottomActive(aColor)[0], TextureFactory.of(
-                TextureFactory.of(STEAM_TURBINE_BOTTOM_ACTIVE),
-                TextureFactory.builder().addIcon(STEAM_TURBINE_BOTTOM_ACTIVE_GLOW).glow().build())};
+        return new ITexture[] {
+            super.getBottomActive(aColor)[0],
+            TextureFactory.of(
+                    TextureFactory.of(STEAM_TURBINE_BOTTOM_ACTIVE),
+                    TextureFactory.builder()
+                            .addIcon(STEAM_TURBINE_BOTTOM_ACTIVE_GLOW)
+                            .glow()
+                            .build())
+        };
     }
 
     @Override
     public ITexture[] getTopActive(byte aColor) {
-        return new ITexture[]{super.getTopActive(aColor)[0], TextureFactory.of(
-                TextureFactory.of(STEAM_TURBINE_TOP_ACTIVE),
-                TextureFactory.builder().addIcon(STEAM_TURBINE_TOP_ACTIVE_GLOW).glow().build())};
+        return new ITexture[] {
+            super.getTopActive(aColor)[0],
+            TextureFactory.of(
+                    TextureFactory.of(STEAM_TURBINE_TOP_ACTIVE),
+                    TextureFactory.builder()
+                            .addIcon(STEAM_TURBINE_TOP_ACTIVE_GLOW)
+                            .glow()
+                            .build())
+        };
     }
 
     @Override
     public ITexture[] getSidesActive(byte aColor) {
-        return new ITexture[]{super.getSidesActive(aColor)[0], TextureFactory.of(
-                TextureFactory.of(STEAM_TURBINE_SIDE_ACTIVE),
-                TextureFactory.builder().addIcon(STEAM_TURBINE_SIDE_ACTIVE_GLOW).glow().build())};
+        return new ITexture[] {
+            super.getSidesActive(aColor)[0],
+            TextureFactory.of(
+                    TextureFactory.of(STEAM_TURBINE_SIDE_ACTIVE),
+                    TextureFactory.builder()
+                            .addIcon(STEAM_TURBINE_SIDE_ACTIVE_GLOW)
+                            .glow()
+                            .build())
+        };
     }
 
     @Override