Forge direction (#1895)

* ForgeDirection

Also refactor the clusterfuck that was `getCoordinateScan`

Co-authored by: Jason Mitchell <mitchej@gmail.com>

* Fix rendering of Frame Boxes

Frame boxes needed their own implementation of getTexture with int connexion mask,
which is returning an error texture for the MetaTileEntity, because pipes (FrameBox
**is** a pipe) do use this method to return different textures based on connexion
status.

---------

Co-authored-by: Léa Gris <lea.gris@noiraude.net>

13 files changed, 128 insertions, 224 deletions

diff --git a/src/main/java/gregtech/api/interfaces/tileentity/IBasicEnergyContainer.java b/src/main/java/gregtech/api/interfaces/tileentity/IBasicEnergyContainer.java
index 4e64742db0..37d62894bb 100644
--- a/src/main/java/gregtech/api/interfaces/tileentity/IBasicEnergyContainer.java
+++ b/src/main/java/gregtech/api/interfaces/tileentity/IBasicEnergyContainer.java
@@ -1,5 +1,7 @@
 package gregtech.api.interfaces.tileentity;
 
+import net.minecraftforge.common.util.ForgeDirection;
+
 /**
  * Interface for internal Code, which is mainly used for independent Energy conversion.
  */
@@ -57,7 +59,7 @@ public interface IBasicEnergyContainer extends IEnergyConnected, IHasWorldObject
     /**
      * Drain Energy Call for Electricity.
      */
-    boolean drainEnergyUnits(byte aSide, long aVoltage, long aAmperage);
+    boolean drainEnergyUnits(ForgeDirection side, long aVoltage, long aAmperage);
 
     /**
      * returns the amount of Electricity, accepted by this Block the last 5 ticks as Average.
diff --git a/src/main/java/gregtech/api/interfaces/tileentity/ICoverable.java b/src/main/java/gregtech/api/interfaces/tileentity/ICoverable.java
index d3186258ef..112a7035d7 100644
--- a/src/main/java/gregtech/api/interfaces/tileentity/ICoverable.java
+++ b/src/main/java/gregtech/api/interfaces/tileentity/ICoverable.java
@@ -2,6 +2,7 @@ package gregtech.api.interfaces.tileentity;
 
 import net.minecraft.entity.player.EntityPlayerMP;
 import net.minecraft.item.ItemStack;
+import net.minecraftforge.common.util.ForgeDirection;
 
 import gregtech.api.util.GT_CoverBehavior;
 import gregtech.api.util.GT_CoverBehaviorBase;
@@ -10,80 +11,81 @@ import gregtech.common.covers.CoverInfo;
 
 public interface ICoverable extends IRedstoneTileEntity, IHasInventory, IBasicEnergyContainer {
 
-    boolean canPlaceCoverIDAtSide(byte aSide, int aID);
+    boolean canPlaceCoverIDAtSide(ForgeDirection side, int aID);
 
-    boolean canPlaceCoverItemAtSide(byte aSide, ItemStack aCover);
+    boolean canPlaceCoverItemAtSide(ForgeDirection side, ItemStack aCover);
 
-    boolean dropCover(byte aSide, byte aDroppedSide, boolean aForced);
+    boolean dropCover(ForgeDirection side, ForgeDirection droppedSide, boolean aForced);
 
     @Deprecated
-    void setCoverDataAtSide(byte aSide, int aData);
+    void setCoverDataAtSide(ForgeDirection side, int aData);
 
-    default void setCoverDataAtSide(byte aSide, ISerializableObject aData) {
+    default void setCoverDataAtSide(ForgeDirection side, ISerializableObject aData) {
         if (aData instanceof ISerializableObject.LegacyCoverData)
-            setCoverDataAtSide(aSide, ((ISerializableObject.LegacyCoverData) aData).get());
+            setCoverDataAtSide(side, ((ISerializableObject.LegacyCoverData) aData).get());
     }
 
-    void setCoverIdAndDataAtSide(byte aSide, int aId, ISerializableObject aData);
+    void setCoverIdAndDataAtSide(ForgeDirection side, int aId, ISerializableObject aData);
 
-    void setCoverIDAtSide(byte aSide, int aID);
+    void setCoverIDAtSide(ForgeDirection side, int aID);
 
-    boolean setCoverIDAtSideNoUpdate(byte aSide, int aID);
+    boolean setCoverIDAtSideNoUpdate(ForgeDirection side, int aID);
 
-    void setCoverItemAtSide(byte aSide, ItemStack aCover);
+    void setCoverItemAtSide(ForgeDirection side, ItemStack aCover);
 
     @Deprecated
-    int getCoverDataAtSide(byte aSide);
+    int getCoverDataAtSide(ForgeDirection side);
 
-    default CoverInfo getCoverInfoAtSide(byte aSide) {
+    default CoverInfo getCoverInfoAtSide(ForgeDirection side) {
         return null;
     }
 
-    default ISerializableObject getComplexCoverDataAtSide(byte aSide) {
-        return new ISerializableObject.LegacyCoverData(getCoverDataAtSide(aSide));
+    default ISerializableObject getComplexCoverDataAtSide(ForgeDirection side) {
+        return new ISerializableObject.LegacyCoverData(getCoverDataAtSide(side));
     }
 
-    int getCoverIDAtSide(byte aSide);
+    int getCoverIDAtSide(ForgeDirection side);
 
-    ItemStack getCoverItemAtSide(byte aSide);
+    ItemStack getCoverItemAtSide(ForgeDirection side);
 
     @Deprecated
-    GT_CoverBehavior getCoverBehaviorAtSide(byte aSide);
+    GT_CoverBehavior getCoverBehaviorAtSide(ForgeDirection side);
 
-    default GT_CoverBehaviorBase<?> getCoverBehaviorAtSideNew(byte aSide) {
-        return getCoverBehaviorAtSide(aSide);
+    default GT_CoverBehaviorBase<?> getCoverBehaviorAtSideNew(ForgeDirection side) {
+        return getCoverBehaviorAtSide(side);
     }
 
     /**
      * For use by the regular MetaTileEntities. Returns the Cover Manipulated input Redstone. Don't use this if you are
      * a Cover Behavior. Only for MetaTileEntities.
      */
-    byte getInternalInputRedstoneSignal(byte aSide);
+    byte getInternalInputRedstoneSignal(ForgeDirection side);
 
     /**
      * For use by the regular MetaTileEntities. This makes it not conflict with Cover based Redstone Signals. Don't use
      * this if you are a Cover Behavior. Only for MetaTileEntities.
      */
-    void setInternalOutputRedstoneSignal(byte aSide, byte aStrength);
+    void setInternalOutputRedstoneSignal(ForgeDirection side, byte aStrength);
 
     /**
      * Causes a general Cover Texture update. Sends 6 Integers to Client + causes @issueTextureUpdate()
      */
-    void issueCoverUpdate(byte aSide);
+    void issueCoverUpdate(ForgeDirection side);
 
     /**
      * Receiving a packet with cover data.
      */
-    void receiveCoverData(byte coverSide, int coverID, int coverData);
+    void receiveCoverData(ForgeDirection coverSide, int coverID, int coverData);
 
     /**
      * Receiving a packet with cover data.
-     * 
-     * @param aPlayer the player who made the change
+     *
+     * @param coverSide
+     * @param aPlayer   the player who made the change
      */
-    default void receiveCoverData(byte aCoverSide, int aCoverID, ISerializableObject aCoverData,
+    default void receiveCoverData(ForgeDirection coverSide, int aCoverID, ISerializableObject aCoverData,
         EntityPlayerMP aPlayer) {
         if (aCoverData instanceof ISerializableObject.LegacyCoverData)
-            receiveCoverData(aCoverSide, aCoverID, ((ISerializableObject.LegacyCoverData) aCoverData).get());
+            receiveCoverData(coverSide, aCoverID, ((ISerializableObject.LegacyCoverData) aCoverData).get());
     }
 }
diff --git a/src/main/java/gregtech/api/interfaces/tileentity/IEnergyConnected.java b/src/main/java/gregtech/api/interfaces/tileentity/IEnergyConnected.java
index 55de2db088..f866092d38 100644
--- a/src/main/java/gregtech/api/interfaces/tileentity/IEnergyConnected.java
+++ b/src/main/java/gregtech/api/interfaces/tileentity/IEnergyConnected.java
@@ -24,28 +24,28 @@ public interface IEnergyConnected extends IColoredTileEntity {
      * <p/>
      * Note: you have to check for @inputEnergyFrom because the Network won't check for that by itself.
      *
-     * @param aSide 0 - 5 = Vanilla Directions of YOUR Block the Energy gets inserted to. 6 = No specific Side (don't do
-     *              Side checks for this Side)
+     * @param side 0 - 5 = Vanilla Directions of YOUR Block the Energy gets inserted to. 6 = No specific Side (don't do
+     *             Side checks for this Side)
      * @return amount of used Amperes. 0 if not accepted anything.
      */
-    long injectEnergyUnits(byte aSide, long aVoltage, long aAmperage);
+    long injectEnergyUnits(ForgeDirection side, long aVoltage, long aAmperage);
 
     /**
      * Sided Energy Input
      */
-    boolean inputEnergyFrom(byte aSide);
+    boolean inputEnergyFrom(ForgeDirection side);
 
-    default boolean inputEnergyFrom(byte aSide, boolean waitForActive) {
-        return inputEnergyFrom(aSide);
+    default boolean inputEnergyFrom(ForgeDirection side, boolean waitForActive) {
+        return inputEnergyFrom(side);
     }
 
     /**
      * Sided Energy Output
      */
-    boolean outputsEnergyTo(byte aSide);
+    boolean outputsEnergyTo(ForgeDirection side);
 
-    default boolean outputsEnergyTo(byte aSide, boolean waitForActive) {
-        return outputsEnergyTo(aSide);
+    default boolean outputsEnergyTo(ForgeDirection side, boolean waitForActive) {
+        return outputsEnergyTo(side);
     }
 
     /**
@@ -64,43 +64,38 @@ public interface IEnergyConnected extends IColoredTileEntity {
                 return 0;
             }
 
-            for (byte i = 0, j = 0; i < 6 && aAmperage > rUsedAmperes; i++) {
-                if (!aEmitter.outputsEnergyTo(i)) {
+            for (final ForgeDirection side : ForgeDirection.VALID_DIRECTIONS) {
+                if (rUsedAmperes > aAmperage) break;
+                if (!aEmitter.outputsEnergyTo(side)) {
                     continue;
                 }
 
-                j = GT_Utility.getOppositeSide(i);
-                final TileEntity tTileEntity = emitterTile.getTileEntityAtSide(i);
+                final ForgeDirection oppositeSide = side.getOpposite();
+                final TileEntity tTileEntity = emitterTile.getTileEntityAtSide(side);
                 if (tTileEntity instanceof PowerLogicHost host) {
 
-                    PowerLogic logic = host.getPowerLogic(ForgeDirection.getOrientation(j));
+                    final PowerLogic logic = host.getPowerLogic(oppositeSide);
                     if (logic == null || logic.isEnergyReceiver()) {
                         continue;
                     }
 
                     rUsedAmperes += logic.injectEnergy(aVoltage, aAmperage - rUsedAmperes);
-                } else if (tTileEntity instanceof IEnergyConnected) {
+                } else if (tTileEntity instanceof IEnergyConnected energyConnected) {
                     if (aEmitter.getColorization() >= 0) {
-                        final byte tColor = ((IEnergyConnected) tTileEntity).getColorization();
+                        final byte tColor = energyConnected.getColorization();
                         if (tColor >= 0 && tColor != aEmitter.getColorization()) continue;
                     }
-                    rUsedAmperes += ((IEnergyConnected) tTileEntity)
-                        .injectEnergyUnits(j, aVoltage, aAmperage - rUsedAmperes);
+                    rUsedAmperes += energyConnected.injectEnergyUnits(oppositeSide, aVoltage, aAmperage - rUsedAmperes);
 
-                } else if (tTileEntity instanceof IEnergySink) {
-                    if (((IEnergySink) tTileEntity)
-                        .acceptsEnergyFrom((TileEntity) aEmitter, ForgeDirection.getOrientation(j))) {
-                        while (aAmperage > rUsedAmperes && ((IEnergySink) tTileEntity).getDemandedEnergy() > 0
-                            && ((IEnergySink) tTileEntity)
-                                .injectEnergy(ForgeDirection.getOrientation(j), aVoltage, aVoltage) < aVoltage)
-                            rUsedAmperes++;
+                } else if (tTileEntity instanceof IEnergySink sink) {
+                    if (sink.acceptsEnergyFrom((TileEntity) aEmitter, oppositeSide)) {
+                        while (aAmperage > rUsedAmperes && sink.getDemandedEnergy() > 0
+                            && sink.injectEnergy(oppositeSide, aVoltage, aVoltage) < aVoltage) rUsedAmperes++;
                     }
-                } else if (GregTech_API.mOutputRF && tTileEntity instanceof IEnergyReceiver) {
-                    final ForgeDirection tDirection = ForgeDirection.getOrientation(i)
-                        .getOpposite();
+                } else if (GregTech_API.mOutputRF && tTileEntity instanceof IEnergyReceiver receiver) {
                     final int rfOut = GT_Utility.safeInt(aVoltage * GregTech_API.mEUtoRF / 100);
-                    if (((IEnergyReceiver) tTileEntity).receiveEnergy(tDirection, rfOut, true) == rfOut) {
-                        ((IEnergyReceiver) tTileEntity).receiveEnergy(tDirection, rfOut, false);
+                    if (receiver.receiveEnergy(oppositeSide, rfOut, true) == rfOut) {
+                        receiver.receiveEnergy(oppositeSide, rfOut, false);
                         rUsedAmperes++;
                     }
                 }
diff --git a/src/main/java/gregtech/api/interfaces/tileentity/IExperimentalEnergyTileEntity.java b/src/main/java/gregtech/api/interfaces/tileentity/IExperimentalEnergyTileEntity.java
deleted file mode 100644
index aa1b9a11c6..0000000000
--- a/src/main/java/gregtech/api/interfaces/tileentity/IExperimentalEnergyTileEntity.java
+++ /dev/null
@@ -1,112 +0,0 @@
-package gregtech.api.interfaces.tileentity;
-
-import net.minecraft.tileentity.TileEntity;
-import net.minecraftforge.common.util.ForgeDirection;
-
-import cofh.api.energy.IEnergyReceiver;
-import gregtech.api.enums.SubTag;
-import gregtech.api.util.GT_Utility;
-import ic2.api.energy.tile.IEnergySink;
-
-/**
- * THIS IS GOING TO BE USED IN 1.8
- * <p/>
- * Interface for getting Connected to the GregTech Energy Network.
- * <p/>
- * This is all you need to connect to the GT Network. IColoredTileEntity is needed for not connecting differently
- * coloured Blocks to each other. IHasWorldObjectAndCoords is needed for the InWorld related Stuff. @BaseTileEntity does
- * implement most of that Interface.
- */
-public interface IExperimentalEnergyTileEntity extends IColoredTileEntity, IHasWorldObjectAndCoords {
-
-    /**
-     * Inject Energy Call for Electricity. Gets called by EnergyEmitters to inject Energy into your Block
-     * <p/>
-     * Note: you have to check for @inputEnergyFrom because the Network won't check for that by itself.
-     *
-     * @param aSide 0 - 5 = Vanilla Directions of YOUR Block the Energy gets inserted to. 6 = No specific Side (don't do
-     *              Side checks for this Side)
-     * @return amount of used Amperes. 0 if not accepted anything.
-     */
-    long injectEnergy(SubTag aEnergyType, byte aSide, long aPrimary, long aSecondary);
-
-    /**
-     * Sided Energy Input
-     */
-    boolean inputEnergyFrom(SubTag aEnergyType, byte aSide);
-
-    /**
-     * Sided Energy Output
-     */
-    boolean outputsEnergyTo(SubTag aEnergyType, byte aSide);
-
-    /**
-     * Utility for the Network
-     */
-    class Util {
-
-        public static int RF_PER_EU = 4;
-        private static boolean RF_ENERGY = false, IC_ENERGY = false, CHECK_ALL = true;
-
-        private static void checkAvailabilities() {
-            if (CHECK_ALL) {
-                try {
-                    Class<IEnergyReceiver> tClass = cofh.api.energy.IEnergyReceiver.class;
-                    tClass.getCanonicalName();
-                    RF_ENERGY = true;
-                } catch (Throwable e) {
-                    /**/
-                }
-                try {
-                    Class<IEnergySink> tClass = ic2.api.energy.tile.IEnergySink.class;
-                    tClass.getCanonicalName();
-                    IC_ENERGY = true;
-                } catch (Throwable e) {
-                    /**/
-                }
-                CHECK_ALL = false;
-            }
-        }
-
-        /**
-         * Emits Energy to the adjacent Blocks. Also compatible with adjacent IC2 TileEntities when electric and RF
-         * TileEntities when RedstoneFlux.
-         *
-         * @return the amount of used secondary value.
-         */
-        public static final long emitEnergyToNetwork(SubTag aEnergyType, long aPrimary, long aSecondary,
-            IExperimentalEnergyTileEntity aEmitter) {
-            long rUsedSecondary = 0;
-            checkAvailabilities();
-            for (byte i = 0, j = 0; i < 6 && aSecondary > rUsedSecondary; i++)
-                if (aEmitter.outputsEnergyTo(aEnergyType, i)) {
-                    j = GT_Utility.getOppositeSide(i);
-                    TileEntity tTileEntity = aEmitter.getTileEntityAtSide(i);
-                    if (tTileEntity instanceof IExperimentalEnergyTileEntity) {
-                        if (aEmitter.getColorization() >= 0) {
-                            byte tColor = ((IExperimentalEnergyTileEntity) tTileEntity).getColorization();
-                            if (tColor >= 0 && tColor != aEmitter.getColorization()) continue;
-                        }
-                        rUsedSecondary += ((IExperimentalEnergyTileEntity) tTileEntity)
-                            .injectEnergy(aEnergyType, j, aPrimary, aSecondary - rUsedSecondary);
-                    } else if (IC_ENERGY && aEnergyType == SubTag.ENERGY_ELECTRICITY
-                        && tTileEntity instanceof IEnergySink) {
-                            if (((IEnergySink) tTileEntity)
-                                .acceptsEnergyFrom((TileEntity) aEmitter, ForgeDirection.getOrientation(j))) {
-                                while (aSecondary > rUsedSecondary
-                                    && ((IEnergySink) tTileEntity).getDemandedEnergy() > 0
-                                    && ((IEnergySink) tTileEntity)
-                                        .injectEnergy(ForgeDirection.getOrientation(j), aPrimary, aPrimary) < aPrimary)
-                                    rUsedSecondary++;
-                            }
-                        } else if (RF_ENERGY && aEnergyType == SubTag.ENERGY_REDSTONE_FLUX
-                            && tTileEntity instanceof IEnergyReceiver
-                            && ((IEnergyReceiver) tTileEntity).canConnectEnergy(ForgeDirection.getOrientation(j))) {
-                                rUsedSecondary += ((IEnergyReceiver) tTileEntity)
-                                    .receiveEnergy(ForgeDirection.getOrientation(j), (int) aSecondary, false);
-                            }
-                }
-            return rUsedSecondary;
-        }
-    }
-}
diff --git a/src/main/java/gregtech/api/interfaces/tileentity/IFibreConnected.java b/src/main/java/gregtech/api/interfaces/tileentity/IFibreConnected.java
index a301c21a76..2f7f26e723 100644
--- a/src/main/java/gregtech/api/interfaces/tileentity/IFibreConnected.java
+++ b/src/main/java/gregtech/api/interfaces/tileentity/IFibreConnected.java
@@ -1,5 +1,7 @@
 package gregtech.api.interfaces.tileentity;
 
+import net.minecraftforge.common.util.ForgeDirection;
+
 /**
  * This File has just internal Information about the Fibre Redstone State of a TileEntity
  */
@@ -8,25 +10,25 @@ public interface IFibreConnected extends IColoredTileEntity, IHasWorldObjectAndC
     /**
      * If this Blocks accepts Fibre from this Side
      */
-    void inputFibreFrom(byte aSide);
+    void inputFibreFrom(ForgeDirection side);
 
     /**
      * If this Blocks emits Fibre to this Side
      */
-    void outputsFibreTo(byte aSide);
+    void outputsFibreTo(ForgeDirection side);
 
     /**
      * Sets the Signal this Blocks outputs to this Fibre Color
      */
-    void setFibreOutput(byte aSide, byte aColor, byte aRedstoneStrength);
+    void setFibreOutput(ForgeDirection side, byte aColor, byte aRedstoneStrength);
 
     /**
      * Gets the Signal this Blocks outputs to this Fibre Color
      */
-    byte getFibreOutput(byte aSide, byte aColor);
+    byte getFibreOutput(ForgeDirection side, byte aColor);
 
     /**
      * Gets the Signal this Blocks receives from this Fibre Color
      */
-    byte getFibreInput(byte aSide, byte aColor);
+    byte getFibreInput(ForgeDirection side, byte aColor);
 }
diff --git a/src/main/java/gregtech/api/interfaces/tileentity/IGearEnergyTileEntity.java b/src/main/java/gregtech/api/interfaces/tileentity/IGearEnergyTileEntity.java
index 31e9b51719..eefcbcb5ac 100644
--- a/src/main/java/gregtech/api/interfaces/tileentity/IGearEnergyTileEntity.java
+++ b/src/main/java/gregtech/api/interfaces/tileentity/IGearEnergyTileEntity.java
@@ -1,18 +1,21 @@
 package gregtech.api.interfaces.tileentity;
 
+import net.minecraftforge.common.util.ForgeDirection;
+
 public interface IGearEnergyTileEntity {
 
     /**
      * If Rotation Energy can be accepted on this Side. This means that the Gear/Axle will connect to this Side, and can
      * cause the Gear/Axle to stop if the Energy isn't accepted.
      */
-    boolean acceptsRotationalEnergy(byte aSide);
+    boolean acceptsRotationalEnergy(ForgeDirection side);
 
     /**
      * Inject Energy Call for Rotational Energy. Rotation Energy can't be stored, this is just for things like internal
      * Dynamos, which convert it into Energy, or into Progress.
      *
+     * @param side
      * @param aSpeed Positive = Clockwise, Negative = Counterclockwise
      */
-    boolean injectRotationalEnergy(byte aSide, long aSpeed, long aEnergy);
+    boolean injectRotationalEnergy(ForgeDirection side, long aSpeed, long aEnergy);
 }
diff --git a/src/main/java/gregtech/api/interfaces/tileentity/IGregTechTileEntity.java b/src/main/java/gregtech/api/interfaces/tileentity/IGregTechTileEntity.java
index 23e4d662c9..5062f0fce5 100644
--- a/src/main/java/gregtech/api/interfaces/tileentity/IGregTechTileEntity.java
+++ b/src/main/java/gregtech/api/interfaces/tileentity/IGregTechTileEntity.java
@@ -10,6 +10,7 @@ import net.minecraft.item.ItemStack;
 import net.minecraft.nbt.NBTTagCompound;
 import net.minecraft.util.AxisAlignedBB;
 import net.minecraft.world.World;
+import net.minecraftforge.common.util.ForgeDirection;
 import net.minecraftforge.fluids.IFluidHandler;
 
 import cpw.mods.fml.relauncher.Side;
@@ -128,9 +129,9 @@ public interface IGregTechTileEntity extends ITexturedTileEntity, IGearEnergyTil
     /**
      * Called when rightclicking the TileEntity
      */
-    boolean onRightclick(EntityPlayer aPlayer, byte aSide, float aX, float aY, float aZ);
+    boolean onRightclick(EntityPlayer aPlayer, ForgeDirection side, float aX, float aY, float aZ);
 
-    float getBlastResistance(byte aSide);
+    float getBlastResistance(ForgeDirection side);
 
     default void onBlockDestroyed() {}
 
diff --git a/src/main/java/gregtech/api/interfaces/tileentity/IHasWorldObjectAndCoords.java b/src/main/java/gregtech/api/interfaces/tileentity/IHasWorldObjectAndCoords.java
index f02672365e..64d206aff7 100644
--- a/src/main/java/gregtech/api/interfaces/tileentity/IHasWorldObjectAndCoords.java
+++ b/src/main/java/gregtech/api/interfaces/tileentity/IHasWorldObjectAndCoords.java
@@ -8,6 +8,7 @@ import net.minecraft.tileentity.TileEntity;
 import net.minecraft.util.ChunkCoordinates;
 import net.minecraft.world.World;
 import net.minecraft.world.biome.BiomeGenBase;
+import net.minecraftforge.common.util.ForgeDirection;
 import net.minecraftforge.fluids.IFluidHandler;
 
 /**
@@ -43,91 +44,91 @@ public interface IHasWorldObjectAndCoords {
 
     TileEntity getTileEntityOffset(int aX, int aY, int aZ);
 
-    TileEntity getTileEntityAtSide(byte aSide);
+    TileEntity getTileEntityAtSide(ForgeDirection side);
 
-    TileEntity getTileEntityAtSideAndDistance(byte aSide, int aDistance);
+    TileEntity getTileEntityAtSideAndDistance(ForgeDirection side, int aDistance);
 
     IInventory getIInventory(int aX, int aY, int aZ);
 
     IInventory getIInventoryOffset(int aX, int aY, int aZ);
 
-    IInventory getIInventoryAtSide(byte aSide);
+    IInventory getIInventoryAtSide(ForgeDirection side);
 
-    IInventory getIInventoryAtSideAndDistance(byte aSide, int aDistance);
+    IInventory getIInventoryAtSideAndDistance(ForgeDirection side, int aDistance);
 
     IFluidHandler getITankContainer(int aX, int aY, int aZ);
 
     IFluidHandler getITankContainerOffset(int aX, int aY, int aZ);
 
-    IFluidHandler getITankContainerAtSide(byte aSide);
+    IFluidHandler getITankContainerAtSide(ForgeDirection side);
 
-    IFluidHandler getITankContainerAtSideAndDistance(byte aSide, int aDistance);
+    IFluidHandler getITankContainerAtSideAndDistance(ForgeDirection side, int aDistance);
 
     IGregTechTileEntity getIGregTechTileEntity(int aX, int aY, int aZ);
 
     IGregTechTileEntity getIGregTechTileEntityOffset(int aX, int aY, int aZ);
 
-    IGregTechTileEntity getIGregTechTileEntityAtSide(byte aSide);
+    IGregTechTileEntity getIGregTechTileEntityAtSide(ForgeDirection side);
 
-    IGregTechTileEntity getIGregTechTileEntityAtSideAndDistance(byte aSide, int aDistance);
+    IGregTechTileEntity getIGregTechTileEntityAtSideAndDistance(ForgeDirection side, int aDistance);
 
     Block getBlock(int aX, int aY, int aZ);
 
     Block getBlockOffset(int aX, int aY, int aZ);
 
-    Block getBlockAtSide(byte aSide);
+    Block getBlockAtSide(ForgeDirection side);
 
-    Block getBlockAtSideAndDistance(byte aSide, int aDistance);
+    Block getBlockAtSideAndDistance(ForgeDirection side, int aDistance);
 
     byte getMetaID(int aX, int aY, int aZ);
 
     byte getMetaIDOffset(int aX, int aY, int aZ);
 
-    byte getMetaIDAtSide(byte aSide);
+    byte getMetaIDAtSide(ForgeDirection side);
 
-    byte getMetaIDAtSideAndDistance(byte aSide, int aDistance);
+    byte getMetaIDAtSideAndDistance(ForgeDirection side, int aDistance);
 
     byte getLightLevel(int aX, int aY, int aZ);
 
     byte getLightLevelOffset(int aX, int aY, int aZ);
 
-    byte getLightLevelAtSide(byte aSide);
+    byte getLightLevelAtSide(ForgeDirection side);
 
-    byte getLightLevelAtSideAndDistance(byte aSide, int aDistance);
+    byte getLightLevelAtSideAndDistance(ForgeDirection side, int aDistance);
 
     boolean getOpacity(int aX, int aY, int aZ);
 
     boolean getOpacityOffset(int aX, int aY, int aZ);
 
-    boolean getOpacityAtSide(byte aSide);
+    boolean getOpacityAtSide(ForgeDirection side);
 
-    boolean getOpacityAtSideAndDistance(byte aSide, int aDistance);
+    boolean getOpacityAtSideAndDistance(ForgeDirection side, int aDistance);
 
     boolean getSky(int aX, int aY, int aZ);
 
     boolean getSkyOffset(int aX, int aY, int aZ);
 
-    boolean getSkyAtSide(byte aSide);
+    boolean getSkyAtSide(ForgeDirection side);
 
-    boolean getSkyAtSideAndDistance(byte aSide, int aDistance);
+    boolean getSkyAtSideAndDistance(ForgeDirection side, int aDistance);
 
     boolean getAir(int aX, int aY, int aZ);
 
     boolean getAirOffset(int aX, int aY, int aZ);
 
-    boolean getAirAtSide(byte aSide);
+    boolean getAirAtSide(ForgeDirection side);
 
-    boolean getAirAtSideAndDistance(byte aSide, int aDistance);
+    boolean getAirAtSideAndDistance(ForgeDirection side, int aDistance);
 
     BiomeGenBase getBiome();
 
     BiomeGenBase getBiome(int aX, int aZ);
 
-    int getOffsetX(byte aSide, int aMultiplier);
+    int getOffsetX(ForgeDirection side, int aMultiplier);
 
-    short getOffsetY(byte aSide, int aMultiplier);
+    short getOffsetY(ForgeDirection side, int aMultiplier);
 
-    int getOffsetZ(byte aSide, int aMultiplier);
+    int getOffsetZ(ForgeDirection side, int aMultiplier);
 
     /**
      * Checks if the TileEntity is Invalid or Unloaded. Stupid Minecraft cannot do that btw.
@@ -168,7 +169,7 @@ public interface IHasWorldObjectAndCoords {
 
     /**
      * Opens the GUI with this ID of this MetaTileEntity
-     * 
+     *
      * @deprecated Use ModularUI
      */
     @Deprecated
@@ -178,7 +179,7 @@ public interface IHasWorldObjectAndCoords {
 
     /**
      * Opens the GUI with the ID = 0 of this TileEntity
-     * 
+     *
      * @deprecated Use ModularUI
      */
     @Deprecated
diff --git a/src/main/java/gregtech/api/interfaces/tileentity/IPipeRenderedTileEntity.java b/src/main/java/gregtech/api/interfaces/tileentity/IPipeRenderedTileEntity.java
index 3cc3c6404d..ab476449f0 100644
--- a/src/main/java/gregtech/api/interfaces/tileentity/IPipeRenderedTileEntity.java
+++ b/src/main/java/gregtech/api/interfaces/tileentity/IPipeRenderedTileEntity.java
@@ -1,5 +1,7 @@
 package gregtech.api.interfaces.tileentity;
 
+import net.minecraftforge.common.util.ForgeDirection;
+
 import gregtech.api.interfaces.ITexture;
 
 public interface IPipeRenderedTileEntity extends ICoverable, ITexturedTileEntity {
@@ -8,9 +10,9 @@ public interface IPipeRenderedTileEntity extends ICoverable, ITexturedTileEntity
 
     byte getConnections();
 
-    ITexture[] getTextureUncovered(byte aSide);
+    ITexture[] getTextureUncovered(ForgeDirection side);
 
-    default ITexture[] getTextureCovered(byte aSide) {
-        return getTextureUncovered(aSide);
+    default ITexture[] getTextureCovered(ForgeDirection side) {
+        return getTextureUncovered(side);
     }
 }
diff --git a/src/main/java/gregtech/api/interfaces/tileentity/IRedstoneEmitter.java b/src/main/java/gregtech/api/interfaces/tileentity/IRedstoneEmitter.java
index fba20ee79d..1b280184ce 100644
--- a/src/main/java/gregtech/api/interfaces/tileentity/IRedstoneEmitter.java
+++ b/src/main/java/gregtech/api/interfaces/tileentity/IRedstoneEmitter.java
@@ -1,5 +1,7 @@
 package gregtech.api.interfaces.tileentity;
 
+import net.minecraftforge.common.util.ForgeDirection;
+
 /**
  * This File has just internal Information about the Redstone State of a TileEntity
  */
@@ -7,8 +9,11 @@ public interface IRedstoneEmitter extends IHasWorldObjectAndCoords {
 
     /**
      * gets the Redstone Level the TileEntity should emit to the given Output Side
+     *
+     * @param side the {@link ForgeDirection} side
+     * @return the Redstone Level the TileEntity
      */
-    byte getOutputRedstoneSignal(byte aSide);
+    byte getOutputRedstoneSignal(ForgeDirection side);
 
     /**
      * sets the Redstone Level the TileEntity should emit to the given Output Side
@@ -17,12 +22,12 @@ public interface IRedstoneEmitter extends IHasWorldObjectAndCoords {
      * internal Output Redstone, so that it doesnt conflict with Cover Redstone. This sets the true Redstone Output
      * Signal. Only Cover Behaviors should use it, not MetaTileEntities.
      */
-    void setOutputRedstoneSignal(byte aSide, byte aStrength);
+    void setOutputRedstoneSignal(ForgeDirection side, byte aStrength);
 
     /**
      * gets the Redstone Level the TileEntity should emit to the given Output Side
      */
-    byte getStrongOutputRedstoneSignal(byte aSide);
+    byte getStrongOutputRedstoneSignal(ForgeDirection side);
 
     /**
      * sets the Redstone Level the TileEntity should emit to the given Output Side
@@ -31,17 +36,17 @@ public interface IRedstoneEmitter extends IHasWorldObjectAndCoords {
      * internal Output Redstone, so that it doesnt conflict with Cover Redstone. This sets the true Redstone Output
      * Signal. Only Cover Behaviors should use it, not MetaTileEntities.
      */
-    void setStrongOutputRedstoneSignal(byte aSide, byte aStrength);
+    void setStrongOutputRedstoneSignal(ForgeDirection side, byte aStrength);
 
     /**
      * Gets the Output for the comparator on the given Side
      */
-    byte getComparatorValue(byte aSide);
+    byte getComparatorValue(ForgeDirection side);
 
     /**
      * Get the redstone output signal strength for a given side
      */
-    default byte getGeneralRS(byte aSide) {
+    default byte getGeneralRS(ForgeDirection side) {
         return 0;
     }
 }
diff --git a/src/main/java/gregtech/api/interfaces/tileentity/IRedstoneReceiver.java b/src/main/java/gregtech/api/interfaces/tileentity/IRedstoneReceiver.java
index d5fb814c52..a41e9aaf7a 100644
--- a/src/main/java/gregtech/api/interfaces/tileentity/IRedstoneReceiver.java
+++ b/src/main/java/gregtech/api/interfaces/tileentity/IRedstoneReceiver.java
@@ -1,5 +1,7 @@
 package gregtech.api.interfaces.tileentity;
 
+import net.minecraftforge.common.util.ForgeDirection;
+
 /**
  * This File has just internal Information about the Redstone State of a TileEntity
  */
@@ -12,7 +14,7 @@ public interface IRedstoneReceiver extends IHasWorldObjectAndCoords {
      * Input Redstone This returns the true incoming Redstone Signal. Only Cover Behaviors should check it, not
      * MetaTileEntities.
      */
-    byte getInputRedstoneSignal(byte aSide);
+    byte getInputRedstoneSignal(ForgeDirection side);
 
     /**
      * gets the strongest Redstone Level the TileEntity receives
@@ -27,5 +29,5 @@ public interface IRedstoneReceiver extends IHasWorldObjectAndCoords {
     /**
      * gets if the TileEntity receives Redstone at this Side
      */
-    boolean getRedstone(byte aSide);
+    boolean getRedstone(ForgeDirection side);
 }
diff --git a/src/main/java/gregtech/api/interfaces/tileentity/ITexturedTileEntity.java b/src/main/java/gregtech/api/interfaces/tileentity/ITexturedTileEntity.java
index d6024b612e..379111b07e 100644
--- a/src/main/java/gregtech/api/interfaces/tileentity/ITexturedTileEntity.java
+++ b/src/main/java/gregtech/api/interfaces/tileentity/ITexturedTileEntity.java
@@ -1,6 +1,7 @@
 package gregtech.api.interfaces.tileentity;
 
 import net.minecraft.block.Block;
+import net.minecraftforge.common.util.ForgeDirection;
 
 import gregtech.api.interfaces.ITexture;
 
@@ -9,5 +10,5 @@ public interface ITexturedTileEntity {
     /**
      * @return the Textures rendered by the GT Rendering
      */
-    ITexture[] getTexture(Block aBlock, byte aSide);
+    ITexture[] getTexture(Block aBlock, ForgeDirection side);
 }
diff --git a/src/main/java/gregtech/api/interfaces/tileentity/ITurnable.java b/src/main/java/gregtech/api/interfaces/tileentity/ITurnable.java
index e54a85090e..64cc8675ef 100644
--- a/src/main/java/gregtech/api/interfaces/tileentity/ITurnable.java
+++ b/src/main/java/gregtech/api/interfaces/tileentity/ITurnable.java
@@ -1,6 +1,6 @@
 package gregtech.api.interfaces.tileentity;
 
-import static gregtech.api.enums.GT_Values.ALL_VALID_SIDES;
+import net.minecraftforge.common.util.ForgeDirection;
 
 /**
  * Implemented by all my Machines. However without any security checks, if the Players are even allowed to rotate it.
@@ -12,34 +12,34 @@ public interface ITurnable {
      *
      * @return front Block facing
      */
-    byte getFrontFacing();
+    ForgeDirection getFrontFacing();
 
     /**
      * Set the block's facing
      *
-     * @param aSide facing to set the block to
+     * @param side facing to set the block to
      */
-    void setFrontFacing(byte aSide);
+    void setFrontFacing(ForgeDirection side);
 
     /**
      * Get the block's back facing.
      *
      * @return opposite Block facing
      */
-    byte getBackFacing();
+    ForgeDirection getBackFacing();
 
     /**
      * Determine if the wrench can be used to set the block's facing.
      */
-    boolean isValidFacing(byte aSide);
+    boolean isValidFacing(ForgeDirection side);
 
     /**
      * Get the list of valid facings
      */
     default boolean[] getValidFacings() {
         final boolean[] validFacings = new boolean[6];
-        for (byte facing : ALL_VALID_SIDES) {
-            validFacings[facing] = isValidFacing(facing);
+        for (final ForgeDirection facing : ForgeDirection.VALID_DIRECTIONS) {
+            validFacings[facing.ordinal()] = isValidFacing(facing);
         }
         return validFacings;
     }