Switch *ALL THE THINGS* to SidedBlock .-. Closes #1674. Also added new prefabs and deprecated Block using ones, closes #1691.

src/main/java/li/cil/oc/api/prefab/DriverBlock.java

@@ -19,7 +19,9 @@ import net.minecraftforge.oredict.OreDictionary;
  * any.
  *
  * @see li.cil.oc.api.network.ManagedEnvironment
+ * @deprecated Use {@link DriverSidedBlock} instead.
  */
+@Deprecated // TODO Remove in OC 1.7
 @SuppressWarnings("UnusedDeclaration")
 public abstract class DriverBlock implements li.cil.oc.api.driver.Block {
     protected final ItemStack[] blocks;

src/main/java/li/cil/oc/api/prefab/DriverSidedBlock.java

@@ -0,0 +1,53 @@
+package li.cil.oc.api.prefab;
+
+import net.minecraft.block.Block;
+import net.minecraft.item.ItemBlock;
+import net.minecraft.item.ItemStack;
+import net.minecraft.world.World;
+import net.minecraftforge.common.util.ForgeDirection;
+import net.minecraftforge.oredict.OreDictionary;
+
+/**
+ * If you wish to create a block component for a third-party block, i.e. a block
+ * for which you do not control the tile entity, such as vanilla blocks, you
+ * will need a block driver.
+ * <p/>
+ * This prefab allows creating a driver that works for a specified list of item
+ * stacks (to support different blocks with the same id but different metadata
+ * values).
+ * <p/>
+ * You still have to provide the implementation for creating its environment, if
+ * any.
+ * <p/>
+ * To limit sidedness, I recommend overriding {@link #worksWith(World, int, int, int, ForgeDirection)}
+ * and calling <code>super.worksWith</code> in addition to the side check.
+ *
+ * @see li.cil.oc.api.network.ManagedEnvironment
+ */
+@SuppressWarnings("UnusedDeclaration")
+public abstract class DriverSidedBlock implements li.cil.oc.api.driver.SidedBlock {
+    protected final ItemStack[] blocks;
+
+    protected DriverSidedBlock(final ItemStack... blocks) {
+        this.blocks = blocks.clone();
+    }
+
+    @Override
+    public boolean worksWith(final World world, final int x, final int y, final int z, final ForgeDirection side) {
+        return worksWith(world.getBlock(x, y, z), world.getBlockMetadata(x, y, z));
+    }
+
+    protected boolean worksWith(final Block referenceBlock, final int referenceMetadata) {
+        for (ItemStack stack : blocks) {
+            if (stack != null && stack.getItem() instanceof ItemBlock) {
+                final ItemBlock item = (ItemBlock) stack.getItem();
+                final Block supportedBlock = item.field_150939_a;
+                final int supportedMetadata = item.getMetadata(stack.getItemDamage());
+                if (referenceBlock == supportedBlock && (referenceMetadata == supportedMetadata || stack.getItemDamage() == OreDictionary.WILDCARD_VALUE)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+}

src/main/java/li/cil/oc/api/prefab/DriverSidedTileEntity.java

@@ -0,0 +1,25 @@
+package li.cil.oc.api.prefab;
+
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.world.World;
+import net.minecraftforge.common.util.ForgeDirection;
+
+/**
+ * To limit sidedness, I recommend overriding {@link #worksWith(World, int, int, int, ForgeDirection)}
+ * and calling <code>super.worksWith</code> in addition to the side check.
+ */
+public abstract class DriverSidedTileEntity implements li.cil.oc.api.driver.SidedBlock {
+    public abstract Class<?> getTileEntityClass();
+
+    @Override
+    public boolean worksWith(final World world, final int x, final int y, final int z, final ForgeDirection side) {
+        final Class<?> filter = getTileEntityClass();
+        if (filter == null) {
+            // This can happen if filter classes are deduced by reflection and
+            // the class in question is not present.
+            return false;
+        }
+        final TileEntity tileEntity = world.getTileEntity(x, y, z);
+        return tileEntity != null && filter.isAssignableFrom(tileEntity.getClass());
+    }
+}

src/main/java/li/cil/oc/api/prefab/DriverTileEntity.java

@@ -3,6 +3,10 @@ package li.cil.oc.api.prefab;
 import net.minecraft.tileentity.TileEntity;
 import net.minecraft.world.World;
 
+/**
+ * @deprecated Use {@link DriverSidedTileEntity} instead.
+ */
+@Deprecated // TODO Remove in OC 1.7
 public abstract class DriverTileEntity implements li.cil.oc.api.driver.Block {
     public abstract Class<?> getTileEntityClass();
 

src/main/scala/li/cil/oc/integration/appeng/DriverBlockInterface.scala

@@ -9,17 +9,18 @@ import li.cil.oc.api.machine.Callback
 import li.cil.oc.api.machine.Context
 import li.cil.oc.api.network.Component
 import li.cil.oc.api.network.ManagedEnvironment
-import li.cil.oc.api.prefab.DriverTileEntity
+import li.cil.oc.api.prefab.DriverSidedTileEntity
 import li.cil.oc.integration.ManagedTileEntityEnvironment
 import li.cil.oc.util.ExtendedArguments._
 import li.cil.oc.util.ResultWrapper._
 import net.minecraft.item.ItemStack
 import net.minecraft.world.World
+import net.minecraftforge.common.util.ForgeDirection
 
-object DriverBlockInterface extends DriverTileEntity {
+object DriverBlockInterface extends DriverSidedTileEntity {
   def getTileEntityClass: Class[_] = classOf[TileInterface]
 
-  def createEnvironment(world: World, x: Int, y: Int, z: Int): ManagedEnvironment =
+  def createEnvironment(world: World, x: Int, y: Int, z: Int, side: ForgeDirection): ManagedEnvironment =
     new Environment(world.getTileEntity(x, y, z).asInstanceOf[TileInterface])
 
   final class Environment(val tile: TileInterface) extends ManagedTileEntityEnvironment[TileInterface](tile, "me_interface") with NamedBlock with NetworkControl[TileInterface] {

src/main/scala/li/cil/oc/integration/appeng/DriverController.scala

@@ -5,20 +5,21 @@ import appeng.me.helpers.IGridProxyable
 import li.cil.oc.api.driver.EnvironmentProvider
 import li.cil.oc.api.driver.NamedBlock
 import li.cil.oc.api.network.ManagedEnvironment
-import li.cil.oc.api.prefab.DriverTileEntity
+import li.cil.oc.api.prefab.DriverSidedTileEntity
 import li.cil.oc.integration.ManagedTileEntityEnvironment
 import net.minecraft.item.ItemStack
 import net.minecraft.tileentity.TileEntity
 import net.minecraft.world.World
+import net.minecraftforge.common.util.ForgeDirection
 
 import scala.language.existentials
 
-object DriverController extends DriverTileEntity {
+object DriverController extends DriverSidedTileEntity {
   private type TileController = TileEntity with IGridProxyable with IActionHost
 
   def getTileEntityClass = AEUtil.controllerClass
 
-  def createEnvironment(world: World, x: Int, y: Int, z: Int): ManagedEnvironment =
+  def createEnvironment(world: World, x: Int, y: Int, z: Int, side: ForgeDirection): ManagedEnvironment =
     new Environment(world.getTileEntity(x, y, z).asInstanceOf[TileController])
 
   final class Environment(val tile: TileController) extends ManagedTileEntityEnvironment[TileController](tile, "me_controller") with NamedBlock with NetworkControl[TileController] {

src/main/scala/li/cil/oc/integration/appeng/DriverExportBus.scala

@@ -25,14 +25,14 @@ import net.minecraftforge.common.util.ForgeDirection
 
 import scala.collection.convert.WrapAsScala._
 
-object DriverExportBus extends driver.Block {
-  override def worksWith(world: World, x: Int, y: Int, z: Int) =
+object DriverExportBus extends driver.SidedBlock {
+  override def worksWith(world: World, x: Int, y: Int, z: Int, side: ForgeDirection) =
     world.getTileEntity(x, y, z) match {
       case container: IPartHost => ForgeDirection.VALID_DIRECTIONS.map(container.getPart).exists(_.isInstanceOf[PartExportBus])
       case _ => false
     }
 
-  override def createEnvironment(world: World, x: Int, y: Int, z: Int) = new Environment(world.getTileEntity(x, y, z).asInstanceOf[IPartHost])
+  override def createEnvironment(world: World, x: Int, y: Int, z: Int, side: ForgeDirection) = new Environment(world.getTileEntity(x, y, z).asInstanceOf[IPartHost])
 
   final class Environment(val host: IPartHost) extends ManagedTileEntityEnvironment[IPartHost](host, "me_exportbus") with NamedBlock with PartEnvironmentBase {
     override def preferredName = "me_exportbus"

src/main/scala/li/cil/oc/integration/appeng/DriverImportBus.scala

@@ -13,14 +13,14 @@ import net.minecraft.item.ItemStack
 import net.minecraft.world.World
 import net.minecraftforge.common.util.ForgeDirection
 
-object DriverImportBus extends driver.Block {
-  override def worksWith(world: World, x: Int, y: Int, z: Int) =
+object DriverImportBus extends driver.SidedBlock {
+  override def worksWith(world: World, x: Int, y: Int, z: Int, side: ForgeDirection) =
     world.getTileEntity(x, y, z) match {
       case container: IPartHost => ForgeDirection.VALID_DIRECTIONS.map(container.getPart).exists(_.isInstanceOf[PartImportBus])
       case _ => false
     }
 
-  override def createEnvironment(world: World, x: Int, y: Int, z: Int) = new Environment(world.getTileEntity(x, y, z).asInstanceOf[IPartHost])
+  override def createEnvironment(world: World, x: Int, y: Int, z: Int, side: ForgeDirection) = new Environment(world.getTileEntity(x, y, z).asInstanceOf[IPartHost])
 
   final class Environment(val host: IPartHost) extends ManagedTileEntityEnvironment[IPartHost](host, "me_importbus") with NamedBlock with PartEnvironmentBase {
     override def preferredName = "me_importbus"

src/main/scala/li/cil/oc/integration/appeng/DriverPartInterface.scala

@@ -13,14 +13,14 @@ import net.minecraft.item.ItemStack
 import net.minecraft.world.World
 import net.minecraftforge.common.util.ForgeDirection
 
-object DriverPartInterface extends driver.Block {
-  override def worksWith(world: World, x: Int, y: Int, z: Int) =
+object DriverPartInterface extends driver.SidedBlock {
+  override def worksWith(world: World, x: Int, y: Int, z: Int, side: ForgeDirection) =
     world.getTileEntity(x, y, z) match {
       case container: IPartHost => ForgeDirection.VALID_DIRECTIONS.map(container.getPart).exists(_.isInstanceOf[PartInterface])
       case _ => false
     }
 
-  override def createEnvironment(world: World, x: Int, y: Int, z: Int) = new Environment(world.getTileEntity(x, y, z).asInstanceOf[IPartHost])
+  override def createEnvironment(world: World, x: Int, y: Int, z: Int, side: ForgeDirection) = new Environment(world.getTileEntity(x, y, z).asInstanceOf[IPartHost])
 
   final class Environment(val host: IPartHost) extends ManagedTileEntityEnvironment[IPartHost](host, "me_interface") with NamedBlock with PartEnvironmentBase {
     override def preferredName = "me_interface"

src/main/scala/li/cil/oc/integration/bloodmagic/DriverBloodAltar.java

@@ -1,23 +1,24 @@
 package li.cil.oc.integration.bloodmagic;
 
+import WayofTime.alchemicalWizardry.api.tile.IBloodAltar;
 import li.cil.oc.api.driver.NamedBlock;
 import li.cil.oc.api.machine.Arguments;
 import li.cil.oc.api.machine.Callback;
 import li.cil.oc.api.machine.Context;
 import li.cil.oc.api.network.ManagedEnvironment;
-import li.cil.oc.api.prefab.DriverTileEntity;
+import li.cil.oc.api.prefab.DriverSidedTileEntity;
 import li.cil.oc.integration.ManagedTileEntityEnvironment;
 import net.minecraft.world.World;
-import WayofTime.alchemicalWizardry.api.tile.IBloodAltar;
+import net.minecraftforge.common.util.ForgeDirection;
 
-public class DriverBloodAltar extends DriverTileEntity {
+public class DriverBloodAltar extends DriverSidedTileEntity {
     @Override
     public Class<?> getTileEntityClass() {
         return IBloodAltar.class;
     }
 
     @Override
-    public ManagedEnvironment createEnvironment(World world, int x, int y, int z) {
+    public ManagedEnvironment createEnvironment(final World world, final int x, final int y, final int z, final ForgeDirection side) {
         return new Environment((IBloodAltar) world.getTileEntity(x, y, z));
     }
 

src/main/scala/li/cil/oc/integration/bloodmagic/DriverMasterRitualStone.java

@@ -7,18 +7,19 @@ import li.cil.oc.api.machine.Arguments;
 import li.cil.oc.api.machine.Callback;
 import li.cil.oc.api.machine.Context;
 import li.cil.oc.api.network.ManagedEnvironment;
-import li.cil.oc.api.prefab.DriverTileEntity;
+import li.cil.oc.api.prefab.DriverSidedTileEntity;
 import li.cil.oc.integration.ManagedTileEntityEnvironment;
 import net.minecraft.world.World;
+import net.minecraftforge.common.util.ForgeDirection;
 
-public class DriverMasterRitualStone extends DriverTileEntity {
+public class DriverMasterRitualStone extends DriverSidedTileEntity {
     @Override
     public Class<?> getTileEntityClass() {
         return IMasterRitualStone.class;
     }
 
     @Override
-    public ManagedEnvironment createEnvironment(World world, int x, int y, int z) {
+    public ManagedEnvironment createEnvironment(final World world, final int x, final int y, final int z, final ForgeDirection side) {
         return new Environment((IMasterRitualStone) world.getTileEntity(x, y, z));
     }
 

src/main/scala/li/cil/oc/integration/buildcraft/tiles/DriverControllable.java

@@ -5,18 +5,19 @@ import li.cil.oc.api.machine.Arguments;
 import li.cil.oc.api.machine.Callback;
 import li.cil.oc.api.machine.Context;
 import li.cil.oc.api.network.ManagedEnvironment;
-import li.cil.oc.api.prefab.DriverTileEntity;
+import li.cil.oc.api.prefab.DriverSidedTileEntity;
 import li.cil.oc.integration.ManagedTileEntityEnvironment;
 import net.minecraft.world.World;
+import net.minecraftforge.common.util.ForgeDirection;
 
-public final class DriverControllable extends DriverTileEntity {
+public final class DriverControllable extends DriverSidedTileEntity {
     @Override
     public Class<?> getTileEntityClass() {
         return IControllable.class;
     }
 
     @Override
-    public ManagedEnvironment createEnvironment(World world, int x, int y, int z) {
+    public ManagedEnvironment createEnvironment(final World world, final int x, final int y, final int z, final ForgeDirection side) {
         return new Environment((IControllable) world.getTileEntity(x, y, z));
     }
 

src/main/scala/li/cil/oc/integration/buildcraft/transport/DriverPipeTile.java

@@ -7,19 +7,19 @@ import li.cil.oc.api.machine.Arguments;
 import li.cil.oc.api.machine.Callback;
 import li.cil.oc.api.machine.Context;
 import li.cil.oc.api.network.ManagedEnvironment;
-import li.cil.oc.api.prefab.DriverTileEntity;
+import li.cil.oc.api.prefab.DriverSidedTileEntity;
 import li.cil.oc.integration.ManagedTileEntityEnvironment;
 import net.minecraft.world.World;
 import net.minecraftforge.common.util.ForgeDirection;
 
-public final class DriverPipeTile extends DriverTileEntity {
+public final class DriverPipeTile extends DriverSidedTileEntity {
     @Override
     public Class<?> getTileEntityClass() {
         return IPipeTile.class;
     }
 
     @Override
-    public ManagedEnvironment createEnvironment(final World world, final int x, final int y, final int z) {
+    public ManagedEnvironment createEnvironment(final World world, final int x, final int y, final int z, final ForgeDirection side) {
         return new Environment((IPipeTile) world.getTileEntity(x, y, z));
     }
 

src/main/scala/li/cil/oc/integration/cofh/energy/DriverEnergyHandler.java

@@ -5,19 +5,19 @@ import li.cil.oc.api.machine.Arguments;
 import li.cil.oc.api.machine.Callback;
 import li.cil.oc.api.machine.Context;
 import li.cil.oc.api.network.ManagedEnvironment;
-import li.cil.oc.api.prefab.DriverTileEntity;
+import li.cil.oc.api.prefab.DriverSidedTileEntity;
 import li.cil.oc.integration.ManagedTileEntityEnvironment;
 import net.minecraft.world.World;
 import net.minecraftforge.common.util.ForgeDirection;
 
-public final class DriverEnergyHandler extends DriverTileEntity {
+public final class DriverEnergyHandler extends DriverSidedTileEntity {
     @Override
     public Class<?> getTileEntityClass() {
         return IEnergyHandler.class;
     }
 
     @Override
-    public ManagedEnvironment createEnvironment(final World world, final int x, final int y, final int z) {
+    public ManagedEnvironment createEnvironment(final World world, final int x, final int y, final int z, final ForgeDirection side) {
         return new Environment((IEnergyHandler) world.getTileEntity(x, y, z));
     }
 

src/main/scala/li/cil/oc/integration/cofh/energy/DriverEnergyProvider.java

@@ -6,19 +6,19 @@ import li.cil.oc.api.machine.Arguments;
 import li.cil.oc.api.machine.Callback;
 import li.cil.oc.api.machine.Context;
 import li.cil.oc.api.network.ManagedEnvironment;
-import li.cil.oc.api.prefab.DriverTileEntity;
+import li.cil.oc.api.prefab.DriverSidedTileEntity;
 import li.cil.oc.integration.ManagedTileEntityEnvironment;
 import net.minecraft.world.World;
 import net.minecraftforge.common.util.ForgeDirection;
 
-public final class DriverEnergyProvider extends DriverTileEntity {
+public final class DriverEnergyProvider extends DriverSidedTileEntity {
     @Override
     public Class<?> getTileEntityClass() {
         return IEnergyProvider.class;
     }
 
     @Override
-    public ManagedEnvironment createEnvironment(final World world, final int x, final int y, final int z) {
+    public ManagedEnvironment createEnvironment(final World world, final int x, final int y, final int z, final ForgeDirection side) {
         return new Environment((IEnergyProvider) world.getTileEntity(x, y, z));
     }
 

src/main/scala/li/cil/oc/integration/cofh/energy/DriverEnergyReceiver.java

@@ -6,24 +6,24 @@ import li.cil.oc.api.machine.Arguments;
 import li.cil.oc.api.machine.Callback;
 import li.cil.oc.api.machine.Context;
 import li.cil.oc.api.network.ManagedEnvironment;
-import li.cil.oc.api.prefab.DriverTileEntity;
+import li.cil.oc.api.prefab.DriverSidedTileEntity;
 import li.cil.oc.integration.ManagedTileEntityEnvironment;
 import net.minecraft.world.World;
 import net.minecraftforge.common.util.ForgeDirection;
 
-public final class DriverEnergyReceiver extends DriverTileEntity {
+public final class DriverEnergyReceiver extends DriverSidedTileEntity {
     @Override
     public Class<?> getTileEntityClass() {
         return IEnergyReceiver.class;
     }
 
     @Override
-    public boolean worksWith(World world, int x, int y, int z) {
-        return super.worksWith(world, x, y, z) && !(world.getTileEntity(x, y, z) instanceof IEnergyProvider);
+    public boolean worksWith(World world, int x, int y, int z, final ForgeDirection side) {
+        return super.worksWith(world, x, y, z, side) && !(world.getTileEntity(x, y, z) instanceof IEnergyProvider);
     }
 
     @Override
-    public ManagedEnvironment createEnvironment(final World world, final int x, final int y, final int z) {
+    public ManagedEnvironment createEnvironment(final World world, final int x, final int y, final int z, final ForgeDirection side) {
         return new Environment((IEnergyReceiver) world.getTileEntity(x, y, z));
     }
 

src/main/scala/li/cil/oc/integration/cofh/tileentity/DriverEnergyInfo.java

@@ -5,18 +5,19 @@ import li.cil.oc.api.machine.Arguments;
 import li.cil.oc.api.machine.Callback;
 import li.cil.oc.api.machine.Context;
 import li.cil.oc.api.network.ManagedEnvironment;
-import li.cil.oc.api.prefab.DriverTileEntity;
+import li.cil.oc.api.prefab.DriverSidedTileEntity;
 import li.cil.oc.integration.ManagedTileEntityEnvironment;
 import net.minecraft.world.World;
+import net.minecraftforge.common.util.ForgeDirection;
 
-public final class DriverEnergyInfo extends DriverTileEntity {
+public final class DriverEnergyInfo extends DriverSidedTileEntity {
     @Override
     public Class<?> getTileEntityClass() {
         return IEnergyInfo.class;
     }
 
     @Override
-    public ManagedEnvironment createEnvironment(final World world, final int x, final int y, final int z) {
+    public ManagedEnvironment createEnvironment(final World world, final int x, final int y, final int z, final ForgeDirection side) {
         return new Environment((IEnergyInfo) world.getTileEntity(x, y, z));
     }
 

src/main/scala/li/cil/oc/integration/cofh/tileentity/DriverRedstoneControl.java

@@ -5,18 +5,19 @@ import li.cil.oc.api.machine.Arguments;
 import li.cil.oc.api.machine.Callback;
 import li.cil.oc.api.machine.Context;
 import li.cil.oc.api.network.ManagedEnvironment;
-import li.cil.oc.api.prefab.DriverTileEntity;
+import li.cil.oc.api.prefab.DriverSidedTileEntity;
 import li.cil.oc.integration.ManagedTileEntityEnvironment;
 import net.minecraft.world.World;
+import net.minecraftforge.common.util.ForgeDirection;
 
-public final class DriverRedstoneControl extends DriverTileEntity {
+public final class DriverRedstoneControl extends DriverSidedTileEntity {
     @Override
     public Class<?> getTileEntityClass() {
         return IRedstoneControl.class;
     }
 
     @Override
-    public ManagedEnvironment createEnvironment(final World world, final int x, final int y, final int z) {
+    public ManagedEnvironment createEnvironment(final World world, final int x, final int y, final int z, final ForgeDirection side) {
         return new Environment((IRedstoneControl) world.getTileEntity(x, y, z));
     }
 

src/main/scala/li/cil/oc/integration/cofh/tileentity/DriverSecureTile.java

@@ -5,19 +5,20 @@ import li.cil.oc.api.machine.Arguments;
 import li.cil.oc.api.machine.Callback;
 import li.cil.oc.api.machine.Context;
 import li.cil.oc.api.network.ManagedEnvironment;
-import li.cil.oc.api.prefab.DriverTileEntity;
+import li.cil.oc.api.prefab.DriverSidedTileEntity;
 import li.cil.oc.integration.ManagedTileEntityEnvironment;
 import net.minecraft.world.World;
+import net.minecraftforge.common.util.ForgeDirection;
 import org.apache.commons.lang3.text.WordUtils;
 
-public final class DriverSecureTile extends DriverTileEntity {
+public final class DriverSecureTile extends DriverSidedTileEntity {
     @Override
     public Class<?> getTileEntityClass() {
         return ISecurable.class;
     }
 
     @Override
-    public ManagedEnvironment createEnvironment(final World world, final int x, final int y, final int z) {
+    public ManagedEnvironment createEnvironment(final World world, final int x, final int y, final int z, final ForgeDirection side) {
         return new Environment((ISecurable) world.getTileEntity(x, y, z));
     }
 

src/main/scala/li/cil/oc/integration/cofh/transport/DriverEnderEnergy.java

@@ -5,18 +5,19 @@ import li.cil.oc.api.machine.Arguments;
 import li.cil.oc.api.machine.Callback;
 import li.cil.oc.api.machine.Context;
 import li.cil.oc.api.network.ManagedEnvironment;
-import li.cil.oc.api.prefab.DriverTileEntity;
+import li.cil.oc.api.prefab.DriverSidedTileEntity;
 import li.cil.oc.integration.ManagedTileEntityEnvironment;
 import net.minecraft.world.World;
+import net.minecraftforge.common.util.ForgeDirection;
 
-public final class DriverEnderEnergy extends DriverTileEntity {
+public final class DriverEnderEnergy extends DriverSidedTileEntity {
     @Override
     public Class<?> getTileEntityClass() {
         return IEnderEnergyHandler.class;
     }
 
     @Override
-    public ManagedEnvironment createEnvironment(final World world, final int x, final int y, final int z) {
+    public ManagedEnvironment createEnvironment(final World world, final int x, final int y, final int z, final ForgeDirection side) {
         return new Environment((IEnderEnergyHandler) world.getTileEntity(x, y, z));
     }
 

src/main/scala/li/cil/oc/integration/cofh/transport/DriverEnderFluid.java

@@ -5,18 +5,19 @@ import li.cil.oc.api.machine.Arguments;
 import li.cil.oc.api.machine.Callback;
 import li.cil.oc.api.machine.Context;
 import li.cil.oc.api.network.ManagedEnvironment;
-import li.cil.oc.api.prefab.DriverTileEntity;
+import li.cil.oc.api.prefab.DriverSidedTileEntity;
 import li.cil.oc.integration.ManagedTileEntityEnvironment;
 import net.minecraft.world.World;
+import net.minecraftforge.common.util.ForgeDirection;
 
-public final class DriverEnderFluid extends DriverTileEntity {
+public final class DriverEnderFluid extends DriverSidedTileEntity {
     @Override
     public Class<?> getTileEntityClass() {
         return IEnderFluidHandler.class;
     }
 
     @Override
-    public ManagedEnvironment createEnvironment(final World world, final int x, final int y, final int z) {
+    public ManagedEnvironment createEnvironment(final World world, final int x, final int y, final int z, final ForgeDirection side) {
         return new Environment((IEnderFluidHandler) world.getTileEntity(x, y, z));
     }
 

src/main/scala/li/cil/oc/integration/cofh/transport/DriverEnderItem.java

@@ -5,18 +5,19 @@ import li.cil.oc.api.machine.Arguments;
 import li.cil.oc.api.machine.Callback;
 import li.cil.oc.api.machine.Context;
 import li.cil.oc.api.network.ManagedEnvironment;
-import li.cil.oc.api.prefab.DriverTileEntity;
+import li.cil.oc.api.prefab.DriverSidedTileEntity;
 import li.cil.oc.integration.ManagedTileEntityEnvironment;
 import net.minecraft.world.World;
+import net.minecraftforge.common.util.ForgeDirection;
 
-public final class DriverEnderItem extends DriverTileEntity {
+public final class DriverEnderItem extends DriverSidedTileEntity {
     @Override
     public Class<?> getTileEntityClass() {
         return IEnderItemHandler.class;
     }
 
     @Override
-    public ManagedEnvironment createEnvironment(final World world, final int x, final int y, final int z) {
+    public ManagedEnvironment createEnvironment(final World world, final int x, final int y, final int z, final ForgeDirection side) {
         return new Environment((IEnderItemHandler) world.getTileEntity(x, y, z));
     }
 

src/main/scala/li/cil/oc/integration/computercraft/DriverPeripheral.java

@@ -20,13 +20,14 @@ import li.cil.oc.api.network.Visibility;
 import li.cil.oc.util.Reflection;
 import net.minecraft.tileentity.TileEntity;
 import net.minecraft.world.World;
+import net.minecraftforge.common.util.ForgeDirection;
 
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Map;
 import java.util.Set;
 
-public final class DriverPeripheral implements li.cil.oc.api.driver.Block {
+public final class DriverPeripheral implements li.cil.oc.api.driver.SidedBlock {
     private static Set<Class<?>> blacklist;
 
     private boolean isBlacklisted(final Object o) {
@@ -53,9 +54,9 @@ public final class DriverPeripheral implements li.cil.oc.api.driver.Block {
         return false;
     }
 
-    private IPeripheral findPeripheral(final World world, final int x, final int y, final int z) {
+    private IPeripheral findPeripheral(final World world, final int x, final int y, final int z, final ForgeDirection side) {
         try {
-            final IPeripheral p = dan200.computercraft.ComputerCraft.getPeripheralAt(world, x, y, z, -1);
+            final IPeripheral p = dan200.computercraft.ComputerCraft.getPeripheralAt(world, x, y, z, side.ordinal());
             if (!isBlacklisted(p)) {
                 return p;
             }
@@ -66,7 +67,7 @@ public final class DriverPeripheral implements li.cil.oc.api.driver.Block {
     }
 
     @Override
-    public boolean worksWith(final World world, final int x, final int y, final int z) {
+    public boolean worksWith(final World world, final int x, final int y, final int z, final ForgeDirection side) {
         final TileEntity tileEntity = world.getTileEntity(x, y, z);
         return tileEntity != null
                 // This ensures we don't get duplicate components, in case the
@@ -76,12 +77,12 @@ public final class DriverPeripheral implements li.cil.oc.api.driver.Block {
                 // to be incompatible with OpenComputers when used directly.
                 && !isBlacklisted(tileEntity)
                 // Actual check if it's a peripheral.
-                && findPeripheral(world, x, y, z) != null;
+                && findPeripheral(world, x, y, z, side) != null;
     }
 
     @Override
-    public ManagedEnvironment createEnvironment(final World world, final int x, final int y, final int z) {
-        return new Environment(findPeripheral(world, x, y, z));
+    public ManagedEnvironment createEnvironment(final World world, final int x, final int y, final int z, final ForgeDirection side) {
+        return new Environment(findPeripheral(world, x, y, z, side));
     }
 
     public static class Environment extends li.cil.oc.api.prefab.ManagedEnvironment implements li.cil.oc.api.network.ManagedPeripheral {

src/main/scala/li/cil/oc/integration/dsu/DriverDeepStorageUnit.scala

@@ -5,16 +5,17 @@ import li.cil.oc.api.machine.Arguments
 import li.cil.oc.api.machine.Callback
 import li.cil.oc.api.machine.Context
 import li.cil.oc.api.network.ManagedEnvironment
-import li.cil.oc.api.prefab.DriverTileEntity
+import li.cil.oc.api.prefab.DriverSidedTileEntity
 import li.cil.oc.integration.ManagedTileEntityEnvironment
 import li.cil.oc.util.ResultWrapper._
 import net.minecraft.world.World
+import net.minecraftforge.common.util.ForgeDirection
 import powercrystals.minefactoryreloaded.api.IDeepStorageUnit
 
-object DriverDeepStorageUnit extends DriverTileEntity {
+object DriverDeepStorageUnit extends DriverSidedTileEntity {
   override def getTileEntityClass: Class[_] = classOf[IDeepStorageUnit]
 
-  override def createEnvironment(world: World, x: Int, y: Int, z: Int): ManagedEnvironment =
+  override def createEnvironment(world: World, x: Int, y: Int, z: Int, side: ForgeDirection): ManagedEnvironment =
     new Environment(world.getTileEntity(x, y, z).asInstanceOf[IDeepStorageUnit])
 
   final class Environment(tileEntity: IDeepStorageUnit) extends ManagedTileEntityEnvironment[IDeepStorageUnit](tileEntity, "deep_storage_unit") {

src/main/scala/li/cil/oc/integration/ec/DriverBlockInterface.scala

@@ -3,16 +3,17 @@ package li.cil.oc.integration.ec
 import appeng.tile.misc.TileInterface
 import li.cil.oc.api.driver.EnvironmentProvider
 import li.cil.oc.api.network.ManagedEnvironment
-import li.cil.oc.api.prefab.DriverTileEntity
+import li.cil.oc.api.prefab.DriverSidedTileEntity
 import li.cil.oc.integration.ManagedTileEntityEnvironment
 import li.cil.oc.integration.appeng.AEUtil
 import net.minecraft.item.ItemStack
 import net.minecraft.world.World
+import net.minecraftforge.common.util.ForgeDirection
 
-object DriverBlockInterface extends DriverTileEntity {
+object DriverBlockInterface extends DriverSidedTileEntity {
   def getTileEntityClass: Class[_] = classOf[TileInterface]
 
-  def createEnvironment(world: World, x: Int, y: Int, z: Int): ManagedEnvironment =
+  def createEnvironment(world: World, x: Int, y: Int, z: Int, side: ForgeDirection): ManagedEnvironment =
     new Environment(world.getTileEntity(x, y, z).asInstanceOf[TileInterface])
 
   final class Environment(val tile: TileInterface) extends ManagedTileEntityEnvironment[TileInterface](tile, "me_interface") with NetworkControl[TileInterface]

src/main/scala/li/cil/oc/integration/ec/DriverController.scala

@@ -4,21 +4,22 @@ import appeng.api.networking.security.IActionHost
 import appeng.me.helpers.IGridProxyable
 import li.cil.oc.api.driver.EnvironmentProvider
 import li.cil.oc.api.network.ManagedEnvironment
-import li.cil.oc.api.prefab.DriverTileEntity
+import li.cil.oc.api.prefab.DriverSidedTileEntity
 import li.cil.oc.integration.ManagedTileEntityEnvironment
 import li.cil.oc.integration.appeng.AEUtil
 import net.minecraft.item.ItemStack
 import net.minecraft.tileentity.TileEntity
 import net.minecraft.world.World
+import net.minecraftforge.common.util.ForgeDirection
 
 import scala.language.existentials
 
-object DriverController extends DriverTileEntity {
+object DriverController extends DriverSidedTileEntity {
   private type TileController = TileEntity with IGridProxyable with IActionHost
 
   def getTileEntityClass = AEUtil.controllerClass
 
-  def createEnvironment(world: World, x: Int, y: Int, z: Int): ManagedEnvironment =
+  def createEnvironment(world: World, x: Int, y: Int, z: Int, side: ForgeDirection): ManagedEnvironment =
     new Environment(world.getTileEntity(x, y, z).asInstanceOf[TileController])
 
   final class Environment(val tile: TileController) extends ManagedTileEntityEnvironment[TileController](tile, "me_controller") with NetworkControl[TileController]

src/main/scala/li/cil/oc/integration/enderstorage/DriverFrequencyOwner.java

@@ -5,18 +5,19 @@ import li.cil.oc.api.machine.Arguments;
 import li.cil.oc.api.machine.Callback;
 import li.cil.oc.api.machine.Context;
 import li.cil.oc.api.network.ManagedEnvironment;
-import li.cil.oc.api.prefab.DriverTileEntity;
+import li.cil.oc.api.prefab.DriverSidedTileEntity;
 import li.cil.oc.integration.ManagedTileEntityEnvironment;
 import net.minecraft.world.World;
+import net.minecraftforge.common.util.ForgeDirection;
 
-public final class DriverFrequencyOwner extends DriverTileEntity {
+public final class DriverFrequencyOwner extends DriverSidedTileEntity {
     @Override
     public Class<?> getTileEntityClass() {
         return TileFrequencyOwner.class;
     }
 
     @Override
-    public ManagedEnvironment createEnvironment(final World world, final int x, final int y, final int z) {
+    public ManagedEnvironment createEnvironment(final World world, final int x, final int y, final int z, final ForgeDirection side) {
         return new Environment((TileFrequencyOwner) world.getTileEntity(x, y, z));
     }
 

src/main/scala/li/cil/oc/integration/forestry/DriverAnalyzer.scala

@@ -6,15 +6,16 @@ import li.cil.oc.api.driver.NamedBlock
 import li.cil.oc.api.machine.Arguments
 import li.cil.oc.api.machine.Callback
 import li.cil.oc.api.machine.Context
-import li.cil.oc.api.prefab.DriverTileEntity
+import li.cil.oc.api.prefab.DriverSidedTileEntity
 import li.cil.oc.integration.ManagedTileEntityEnvironment
 import li.cil.oc.util.ResultWrapper._
 import net.minecraft.world.World
+import net.minecraftforge.common.util.ForgeDirection
 
-class DriverAnalyzer extends DriverTileEntity {
+class DriverAnalyzer extends DriverSidedTileEntity {
   override def getTileEntityClass = classOf[TileAnalyzer]
 
-  override def createEnvironment(world: World, x: Int, y: Int, z: Int) = new Environment(world.getTileEntity(x, y, z).asInstanceOf[TileAnalyzer])
+  override def createEnvironment(world: World, x: Int, y: Int, z: Int, side: ForgeDirection) = new Environment(world.getTileEntity(x, y, z).asInstanceOf[TileAnalyzer])
 
   final class Environment(tileEntity: TileAnalyzer) extends ManagedTileEntityEnvironment[TileAnalyzer](tileEntity, "forestry_analyzer") with NamedBlock {
     override def preferredName = "forestry_analyzer"

src/main/scala/li/cil/oc/integration/forestry/DriverBeeHouse.java

@@ -11,23 +11,24 @@ import li.cil.oc.api.machine.Arguments;
 import li.cil.oc.api.machine.Callback;
 import li.cil.oc.api.machine.Context;
 import li.cil.oc.api.network.ManagedEnvironment;
-import li.cil.oc.api.prefab.DriverTileEntity;
+import li.cil.oc.api.prefab.DriverSidedTileEntity;
 import li.cil.oc.integration.ManagedTileEntityEnvironment;
 import net.minecraft.item.ItemStack;
 import net.minecraft.world.World;
+import net.minecraftforge.common.util.ForgeDirection;
 
 import java.util.HashMap;
 import java.util.Map;
 import java.util.Set;
 
-public class DriverBeeHouse extends DriverTileEntity {
+public class DriverBeeHouse extends DriverSidedTileEntity {
     @Override
     public Class<?> getTileEntityClass() {
         return IBeeHousing.class;
     }
 
     @Override
-    public ManagedEnvironment createEnvironment(final World world, final int x, final int y, final int z) {
+    public ManagedEnvironment createEnvironment(final World world, final int x, final int y, final int z, final ForgeDirection side) {
         return new Environment((IBeeHousing) world.getTileEntity(x, y, z));
     }
 

src/main/scala/li/cil/oc/integration/gregtech/DriverEnergyContainer.java

@@ -5,18 +5,19 @@ import li.cil.oc.api.machine.Arguments;
 import li.cil.oc.api.machine.Callback;
 import li.cil.oc.api.machine.Context;
 import li.cil.oc.api.network.ManagedEnvironment;
-import li.cil.oc.api.prefab.DriverTileEntity;
+import li.cil.oc.api.prefab.DriverSidedTileEntity;
 import li.cil.oc.integration.ManagedTileEntityEnvironment;
 import net.minecraft.world.World;
+import net.minecraftforge.common.util.ForgeDirection;
 
-public final class DriverEnergyContainer extends DriverTileEntity {
+public final class DriverEnergyContainer extends DriverSidedTileEntity {
     @Override
     public Class<?> getTileEntityClass() {
         return IBasicEnergyContainer.class;
     }
 
     @Override
-    public ManagedEnvironment createEnvironment(final World world, final int x, final int y, final int z) {
+    public ManagedEnvironment createEnvironment(final World world, final int x, final int y, final int z, final ForgeDirection side) {
         return new Environment((IBasicEnergyContainer) world.getTileEntity(x, y, z));
     }
 

src/main/scala/li/cil/oc/integration/ic2/DriverEnergyConductor.java

@@ -5,18 +5,19 @@ import li.cil.oc.api.machine.Arguments;
 import li.cil.oc.api.machine.Callback;
 import li.cil.oc.api.machine.Context;
 import li.cil.oc.api.network.ManagedEnvironment;
-import li.cil.oc.api.prefab.DriverTileEntity;
+import li.cil.oc.api.prefab.DriverSidedTileEntity;
 import li.cil.oc.integration.ManagedTileEntityEnvironment;
 import net.minecraft.world.World;
+import net.minecraftforge.common.util.ForgeDirection;
 
-public final class DriverEnergyConductor extends DriverTileEntity {
+public final class DriverEnergyConductor extends DriverSidedTileEntity {
     @Override
     public Class<?> getTileEntityClass() {
         return IEnergyConductor.class;
     }
 
     @Override
-    public ManagedEnvironment createEnvironment(final World world, final int x, final int y, final int z) {
+    public ManagedEnvironment createEnvironment(final World world, final int x, final int y, final int z, final ForgeDirection side) {
         return new Environment((IEnergyConductor) world.getTileEntity(x, y, z));
     }
 

src/main/scala/li/cil/oc/integration/ic2/DriverEnergySink.java

@@ -5,18 +5,19 @@ import li.cil.oc.api.machine.Arguments;
 import li.cil.oc.api.machine.Callback;
 import li.cil.oc.api.machine.Context;
 import li.cil.oc.api.network.ManagedEnvironment;
-import li.cil.oc.api.prefab.DriverTileEntity;
+import li.cil.oc.api.prefab.DriverSidedTileEntity;
 import li.cil.oc.integration.ManagedTileEntityEnvironment;
 import net.minecraft.world.World;
+import net.minecraftforge.common.util.ForgeDirection;
 
-public final class DriverEnergySink extends DriverTileEntity {
+public final class DriverEnergySink extends DriverSidedTileEntity {
     @Override
     public Class<?> getTileEntityClass() {
         return IEnergySink.class;
     }
 
     @Override
-    public ManagedEnvironment createEnvironment(final World world, final int x, final int y, final int z) {
+    public ManagedEnvironment createEnvironment(final World world, final int x, final int y, final int z, final ForgeDirection side) {
         return new Environment((IEnergySink) world.getTileEntity(x, y, z));
     }
 

src/main/scala/li/cil/oc/integration/ic2/DriverEnergySource.java

@@ -5,18 +5,19 @@ import li.cil.oc.api.machine.Arguments;
 import li.cil.oc.api.machine.Callback;
 import li.cil.oc.api.machine.Context;
 import li.cil.oc.api.network.ManagedEnvironment;
-import li.cil.oc.api.prefab.DriverTileEntity;
+import li.cil.oc.api.prefab.DriverSidedTileEntity;
 import li.cil.oc.integration.ManagedTileEntityEnvironment;
 import net.minecraft.world.World;
+import net.minecraftforge.common.util.ForgeDirection;
 
-public final class DriverEnergySource extends DriverTileEntity {
+public final class DriverEnergySource extends DriverSidedTileEntity {
     @Override
     public Class<?> getTileEntityClass() {
         return IEnergySource.class;
     }
 
     @Override
-    public ManagedEnvironment createEnvironment(final World world, final int x, final int y, final int z) {
+    public ManagedEnvironment createEnvironment(final World world, final int x, final int y, final int z, final ForgeDirection side) {
         return new Environment((IEnergySource) world.getTileEntity(x, y, z));
     }
 

src/main/scala/li/cil/oc/integration/ic2/DriverEnergyStorage.java

@@ -5,18 +5,19 @@ import li.cil.oc.api.machine.Arguments;
 import li.cil.oc.api.machine.Callback;
 import li.cil.oc.api.machine.Context;
 import li.cil.oc.api.network.ManagedEnvironment;
-import li.cil.oc.api.prefab.DriverTileEntity;
+import li.cil.oc.api.prefab.DriverSidedTileEntity;
 import li.cil.oc.integration.ManagedTileEntityEnvironment;
 import net.minecraft.world.World;
+import net.minecraftforge.common.util.ForgeDirection;
 
-public final class DriverEnergyStorage extends DriverTileEntity {
+public final class DriverEnergyStorage extends DriverSidedTileEntity {
     @Override
     public Class<?> getTileEntityClass() {
         return IEnergyStorage.class;
     }
 
     @Override
-    public ManagedEnvironment createEnvironment(final World world, final int x, final int y, final int z) {
+    public ManagedEnvironment createEnvironment(final World world, final int x, final int y, final int z, final ForgeDirection side) {
         return new Environment((IEnergyStorage) world.getTileEntity(x, y, z));
     }
 

src/main/scala/li/cil/oc/integration/ic2/DriverMassFab.java

@@ -5,19 +5,20 @@ import li.cil.oc.api.driver.NamedBlock;
 import li.cil.oc.api.machine.Arguments;
 import li.cil.oc.api.machine.Callback;
 import li.cil.oc.api.machine.Context;
-import li.cil.oc.api.prefab.DriverTileEntity;
+import li.cil.oc.api.prefab.DriverSidedTileEntity;
 import li.cil.oc.api.prefab.ManagedEnvironment;
 import li.cil.oc.integration.ManagedTileEntityEnvironment;
 import net.minecraft.world.World;
+import net.minecraftforge.common.util.ForgeDirection;
 
-public final class DriverMassFab extends DriverTileEntity {
+public final class DriverMassFab extends DriverSidedTileEntity {
     @Override
     public Class<?> getTileEntityClass() {
         return TileEntityMatter.class;
     }
 
     @Override
-    public ManagedEnvironment createEnvironment(final World world, final int x, final int y, final int z) {
+    public ManagedEnvironment createEnvironment(final World world, final int x, final int y, final int z, final ForgeDirection side) {
         return new Environment((TileEntityMatter) world.getTileEntity(x, y, z));
     }
 

src/main/scala/li/cil/oc/integration/ic2/DriverReactor.java

@@ -7,18 +7,19 @@ import li.cil.oc.api.machine.Arguments;
 import li.cil.oc.api.machine.Callback;
 import li.cil.oc.api.machine.Context;
 import li.cil.oc.api.network.ManagedEnvironment;
-import li.cil.oc.api.prefab.DriverTileEntity;
+import li.cil.oc.api.prefab.DriverSidedTileEntity;
 import li.cil.oc.integration.ManagedTileEntityEnvironment;
 import net.minecraft.world.World;
+import net.minecraftforge.common.util.ForgeDirection;
 
-public final class DriverReactor extends DriverTileEntity {
+public final class DriverReactor extends DriverSidedTileEntity {
     @Override
     public Class<?> getTileEntityClass() {
         return IReactor.class;
     }
 
     @Override
-    public ManagedEnvironment createEnvironment(final World world, final int x, final int y, final int z) {
+    public ManagedEnvironment createEnvironment(final World world, final int x, final int y, final int z, final ForgeDirection side) {
         return new Environment((IReactor) world.getTileEntity(x, y, z));
     }
 

src/main/scala/li/cil/oc/integration/ic2/DriverReactorChamber.java

@@ -7,18 +7,19 @@ import li.cil.oc.api.machine.Arguments;
 import li.cil.oc.api.machine.Callback;
 import li.cil.oc.api.machine.Context;
 import li.cil.oc.api.network.ManagedEnvironment;
-import li.cil.oc.api.prefab.DriverTileEntity;
+import li.cil.oc.api.prefab.DriverSidedTileEntity;
 import li.cil.oc.integration.ManagedTileEntityEnvironment;
 import net.minecraft.world.World;
+import net.minecraftforge.common.util.ForgeDirection;
 
-public final class DriverReactorChamber extends DriverTileEntity {
+public final class DriverReactorChamber extends DriverSidedTileEntity {
     @Override
     public Class<?> getTileEntityClass() {
         return IReactorChamber.class;
     }
 
     @Override
-    public ManagedEnvironment createEnvironment(final World world, final int x, final int y, final int z) {
+    public ManagedEnvironment createEnvironment(final World world, final int x, final int y, final int z, final ForgeDirection side) {
         return new Environment((IReactorChamber) world.getTileEntity(x, y, z));
     }
 

src/main/scala/li/cil/oc/integration/railcraft/DriverBoilerFirebox.java

@@ -5,14 +5,15 @@ import li.cil.oc.api.machine.Arguments;
 import li.cil.oc.api.machine.Callback;
 import li.cil.oc.api.machine.Context;
 import li.cil.oc.api.network.ManagedEnvironment;
-import li.cil.oc.api.prefab.DriverTileEntity;
+import li.cil.oc.api.prefab.DriverSidedTileEntity;
 import li.cil.oc.integration.ManagedTileEntityEnvironment;
 import mods.railcraft.common.blocks.machine.beta.TileBoilerFirebox;
 import net.minecraft.world.World;
+import net.minecraftforge.common.util.ForgeDirection;
 
-public class DriverBoilerFirebox extends DriverTileEntity {
+public class DriverBoilerFirebox extends DriverSidedTileEntity {
     @Override
-    public ManagedEnvironment createEnvironment(final World world, final int x, final int y, final int z) {
+    public ManagedEnvironment createEnvironment(final World world, final int x, final int y, final int z, final ForgeDirection side) {
         return new Environment((TileBoilerFirebox) world.getTileEntity(x, y, z));
     }
 

src/main/scala/li/cil/oc/integration/railcraft/DriverSteamTurbine.java

@@ -5,21 +5,22 @@ import li.cil.oc.api.machine.Arguments;
 import li.cil.oc.api.machine.Callback;
 import li.cil.oc.api.machine.Context;
 import li.cil.oc.api.network.ManagedEnvironment;
-import li.cil.oc.api.prefab.DriverTileEntity;
+import li.cil.oc.api.prefab.DriverSidedTileEntity;
 import li.cil.oc.integration.ManagedTileEntityEnvironment;
 import mods.railcraft.common.blocks.machine.alpha.TileSteamTurbine;
 import net.minecraft.inventory.IInventory;
 import net.minecraft.item.ItemStack;
 import net.minecraft.world.World;
+import net.minecraftforge.common.util.ForgeDirection;
 
-public final class DriverSteamTurbine extends DriverTileEntity {
+public final class DriverSteamTurbine extends DriverSidedTileEntity {
     @Override
     public Class<?> getTileEntityClass() {
         return TileSteamTurbine.class;
     }
 
     @Override
-    public ManagedEnvironment createEnvironment(final World world, final int x, final int y, final int z) {
+    public ManagedEnvironment createEnvironment(final World world, final int x, final int y, final int z, final ForgeDirection side) {
         return new Environment((TileSteamTurbine) world.getTileEntity(x, y, z));
     }
 

src/main/scala/li/cil/oc/integration/thaumcraft/DriverAspectContainer.java

@@ -5,16 +5,17 @@ import li.cil.oc.api.machine.Arguments;
 import li.cil.oc.api.machine.Callback;
 import li.cil.oc.api.machine.Context;
 import li.cil.oc.api.network.ManagedEnvironment;
-import li.cil.oc.api.prefab.DriverTileEntity;
+import li.cil.oc.api.prefab.DriverSidedTileEntity;
 import li.cil.oc.integration.ManagedTileEntityEnvironment;
 import net.minecraft.world.World;
+import net.minecraftforge.common.util.ForgeDirection;
 import thaumcraft.api.aspects.Aspect;
 import thaumcraft.api.aspects.AspectList;
 import thaumcraft.api.aspects.IAspectContainer;
 
-public class DriverAspectContainer extends DriverTileEntity {
+public class DriverAspectContainer extends DriverSidedTileEntity {
     @Override
-    public ManagedEnvironment createEnvironment(final World world, final int x, final int y, final int z) {
+    public ManagedEnvironment createEnvironment(final World world, final int x, final int y, final int z, final ForgeDirection side) {
         return new Environment((IAspectContainer) world.getTileEntity(x, y, z));
     }
 

src/main/scala/li/cil/oc/integration/thaumicenergistics/DriverBlockInterface.scala

@@ -3,16 +3,17 @@ package li.cil.oc.integration.thaumicenergistics
 import appeng.tile.misc.TileInterface
 import li.cil.oc.api.driver.EnvironmentProvider
 import li.cil.oc.api.network.ManagedEnvironment
-import li.cil.oc.api.prefab.DriverTileEntity
+import li.cil.oc.api.prefab.DriverSidedTileEntity
 import li.cil.oc.integration.ManagedTileEntityEnvironment
 import li.cil.oc.integration.appeng.AEUtil
 import net.minecraft.item.ItemStack
 import net.minecraft.world.World
+import net.minecraftforge.common.util.ForgeDirection
 
-object DriverBlockInterface extends DriverTileEntity {
+object DriverBlockInterface extends DriverSidedTileEntity {
   def getTileEntityClass: Class[_] = classOf[TileInterface]
 
-  def createEnvironment(world: World, x: Int, y: Int, z: Int): ManagedEnvironment =
+  def createEnvironment(world: World, x: Int, y: Int, z: Int, side: ForgeDirection): ManagedEnvironment =
     new Environment(world.getTileEntity(x, y, z).asInstanceOf[TileInterface])
 
   final class Environment(val tile: TileInterface) extends ManagedTileEntityEnvironment[TileInterface](tile, "me_interface") with NetworkControl[TileInterface]

src/main/scala/li/cil/oc/integration/thaumicenergistics/DriverController.scala

@@ -4,21 +4,22 @@ import appeng.api.networking.security.IActionHost
 import appeng.me.helpers.IGridProxyable
 import li.cil.oc.api.driver.EnvironmentProvider
 import li.cil.oc.api.network.ManagedEnvironment
-import li.cil.oc.api.prefab.DriverTileEntity
+import li.cil.oc.api.prefab.DriverSidedTileEntity
 import li.cil.oc.integration.ManagedTileEntityEnvironment
 import li.cil.oc.integration.appeng.AEUtil
 import net.minecraft.item.ItemStack
 import net.minecraft.tileentity.TileEntity
 import net.minecraft.world.World
+import net.minecraftforge.common.util.ForgeDirection
 
 import scala.language.existentials
 
-object DriverController extends DriverTileEntity {
+object DriverController extends DriverSidedTileEntity {
   private type TileController = TileEntity with IGridProxyable with IActionHost
 
   def getTileEntityClass = AEUtil.controllerClass
 
-  def createEnvironment(world: World, x: Int, y: Int, z: Int): ManagedEnvironment =
+  def createEnvironment(world: World, x: Int, y: Int, z: Int, side: ForgeDirection): ManagedEnvironment =
     new Environment(world.getTileEntity(x, y, z).asInstanceOf[TileController])
 
   final class Environment(val tile: TileController) extends ManagedTileEntityEnvironment[TileController](tile, "me_controller") with NetworkControl[TileController]

src/main/scala/li/cil/oc/integration/thermalexpansion/DriverLamp.java

@@ -3,14 +3,15 @@ package li.cil.oc.integration.thermalexpansion;
 import li.cil.oc.api.machine.Arguments;
 import li.cil.oc.api.machine.Callback;
 import li.cil.oc.api.machine.Context;
-import li.cil.oc.api.prefab.DriverTileEntity;
+import li.cil.oc.api.prefab.DriverSidedTileEntity;
 import li.cil.oc.api.prefab.ManagedEnvironment;
 import li.cil.oc.integration.ManagedTileEntityEnvironment;
 import li.cil.oc.util.Reflection;
 import net.minecraft.tileentity.TileEntity;
 import net.minecraft.world.World;
+import net.minecraftforge.common.util.ForgeDirection;
 
-public final class DriverLamp extends DriverTileEntity {
+public final class DriverLamp extends DriverSidedTileEntity {
     private static final Class<?> TileLamp = Reflection.getClass("thermalexpansion.block.lamp.TileLamp");
 
     @Override
@@ -19,7 +20,7 @@ public final class DriverLamp extends DriverTileEntity {
     }
 
     @Override
-    public ManagedEnvironment createEnvironment(final World world, final int x, final int y, final int z) {
+    public ManagedEnvironment createEnvironment(final World world, final int x, final int y, final int z, final ForgeDirection side) {
         return new Environment(world.getTileEntity(x, y, z));
     }
 

src/main/scala/li/cil/oc/integration/tmechworks/DriverDrawBridge.java

@@ -4,19 +4,20 @@ import li.cil.oc.api.machine.Arguments;
 import li.cil.oc.api.machine.Callback;
 import li.cil.oc.api.machine.Context;
 import li.cil.oc.api.network.ManagedEnvironment;
-import li.cil.oc.api.prefab.DriverTileEntity;
+import li.cil.oc.api.prefab.DriverSidedTileEntity;
 import li.cil.oc.integration.ManagedTileEntityEnvironment;
 import net.minecraft.world.World;
+import net.minecraftforge.common.util.ForgeDirection;
 import tmechworks.lib.blocks.IDrawbridgeLogicBase;
 
-public class DriverDrawBridge extends DriverTileEntity {
+public class DriverDrawBridge extends DriverSidedTileEntity {
     @Override
     public Class<?> getTileEntityClass() {
         return IDrawbridgeLogicBase.class;
     }
 
     @Override
-    public ManagedEnvironment createEnvironment(final World world, final int x, final int y, final int z) {
+    public ManagedEnvironment createEnvironment(final World world, final int x, final int y, final int z, final ForgeDirection side) {
         return new Environment((IDrawbridgeLogicBase) world.getTileEntity(x, y, z));
     }
 

src/main/scala/li/cil/oc/integration/vanilla/DriverBeacon.scala

@@ -6,7 +6,7 @@ import li.cil.oc.api.machine.Arguments
 import li.cil.oc.api.machine.Callback
 import li.cil.oc.api.machine.Context
 import li.cil.oc.api.network.ManagedEnvironment
-import li.cil.oc.api.prefab.DriverTileEntity
+import li.cil.oc.api.prefab.DriverSidedTileEntity
 import li.cil.oc.integration.ManagedTileEntityEnvironment
 import li.cil.oc.util.ResultWrapper.result
 import net.minecraft.block.Block
@@ -15,11 +15,12 @@ import net.minecraft.item.ItemStack
 import net.minecraft.potion.Potion
 import net.minecraft.tileentity.TileEntityBeacon
 import net.minecraft.world.World
+import net.minecraftforge.common.util.ForgeDirection
 
-object DriverBeacon extends DriverTileEntity {
+object DriverBeacon extends DriverSidedTileEntity {
   override def getTileEntityClass: Class[_] = classOf[TileEntityBeacon]
 
-  override def createEnvironment(world: World, x: Int, y: Int, z: Int): ManagedEnvironment =
+  override def createEnvironment(world: World, x: Int, y: Int, z: Int, side: ForgeDirection): ManagedEnvironment =
     new Environment(world.getTileEntity(x, y, z).asInstanceOf[TileEntityBeacon])
 
   final class Environment(tileEntity: TileEntityBeacon) extends ManagedTileEntityEnvironment[TileEntityBeacon](tileEntity, "beacon") with NamedBlock {

src/main/scala/li/cil/oc/integration/vanilla/DriverBrewingStand.scala

@@ -6,18 +6,19 @@ import li.cil.oc.api.machine.Arguments
 import li.cil.oc.api.machine.Callback
 import li.cil.oc.api.machine.Context
 import li.cil.oc.api.network.ManagedEnvironment
-import li.cil.oc.api.prefab.DriverTileEntity
+import li.cil.oc.api.prefab.DriverSidedTileEntity
 import li.cil.oc.integration.ManagedTileEntityEnvironment
 import li.cil.oc.util.ResultWrapper.result
 import net.minecraft.init.Items
 import net.minecraft.item.ItemStack
 import net.minecraft.tileentity.TileEntityBrewingStand
 import net.minecraft.world.World
+import net.minecraftforge.common.util.ForgeDirection
 
-object DriverBrewingStand extends DriverTileEntity {
+object DriverBrewingStand extends DriverSidedTileEntity {
   override def getTileEntityClass: Class[_] = classOf[TileEntityBrewingStand]
 
-  override def createEnvironment(world: World, x: Int, y: Int, z: Int): ManagedEnvironment =
+  override def createEnvironment(world: World, x: Int, y: Int, z: Int, side: ForgeDirection): ManagedEnvironment =
     new Environment(world.getTileEntity(x, y, z).asInstanceOf[TileEntityBrewingStand])
 
   final class Environment(tileEntity: TileEntityBrewingStand) extends ManagedTileEntityEnvironment[TileEntityBrewingStand](tileEntity, "brewing_stand") with NamedBlock {

src/main/scala/li/cil/oc/integration/vanilla/DriverCommandBlock.scala

@@ -6,7 +6,7 @@ import li.cil.oc.api.machine.Arguments
 import li.cil.oc.api.machine.Callback
 import li.cil.oc.api.machine.Context
 import li.cil.oc.api.network.ManagedEnvironment
-import li.cil.oc.api.prefab.DriverTileEntity
+import li.cil.oc.api.prefab.DriverSidedTileEntity
 import li.cil.oc.integration.ManagedTileEntityEnvironment
 import li.cil.oc.util.ResultWrapper.result
 import net.minecraft.block.Block
@@ -15,11 +15,12 @@ import net.minecraft.item.ItemStack
 import net.minecraft.server.MinecraftServer
 import net.minecraft.tileentity.TileEntityCommandBlock
 import net.minecraft.world.World
+import net.minecraftforge.common.util.ForgeDirection
 
-object DriverCommandBlock extends DriverTileEntity {
+object DriverCommandBlock extends DriverSidedTileEntity {
   override def getTileEntityClass: Class[_] = classOf[TileEntityCommandBlock]
 
-  override def createEnvironment(world: World, x: Int, y: Int, z: Int): ManagedEnvironment =
+  override def createEnvironment(world: World, x: Int, y: Int, z: Int, side: ForgeDirection): ManagedEnvironment =
     new Environment(world.getTileEntity(x, y, z).asInstanceOf[TileEntityCommandBlock])
 
   final class Environment(tileEntity: TileEntityCommandBlock) extends ManagedTileEntityEnvironment[TileEntityCommandBlock](tileEntity, "command_block") with NamedBlock {

src/main/scala/li/cil/oc/integration/vanilla/DriverComparator.scala

@@ -6,18 +6,19 @@ import li.cil.oc.api.machine.Arguments
 import li.cil.oc.api.machine.Callback
 import li.cil.oc.api.machine.Context
 import li.cil.oc.api.network.ManagedEnvironment
-import li.cil.oc.api.prefab.DriverTileEntity
+import li.cil.oc.api.prefab.DriverSidedTileEntity
 import li.cil.oc.integration.ManagedTileEntityEnvironment
 import li.cil.oc.util.ResultWrapper.result
 import net.minecraft.init.Items
 import net.minecraft.item.ItemStack
 import net.minecraft.tileentity.TileEntityComparator
 import net.minecraft.world.World
+import net.minecraftforge.common.util.ForgeDirection
 
-object DriverComparator extends DriverTileEntity {
+object DriverComparator extends DriverSidedTileEntity {
   override def getTileEntityClass: Class[_] = classOf[TileEntityComparator]
 
-  override def createEnvironment(world: World, x: Int, y: Int, z: Int): ManagedEnvironment =
+  override def createEnvironment(world: World, x: Int, y: Int, z: Int, side: ForgeDirection): ManagedEnvironment =
     new Environment(world.getTileEntity(x, y, z).asInstanceOf[TileEntityComparator])
 
   final class Environment(tileEntity: TileEntityComparator) extends ManagedTileEntityEnvironment[TileEntityComparator](tileEntity, "comparator") with NamedBlock {

src/main/scala/li/cil/oc/integration/vanilla/DriverFluidHandler.java

@@ -4,20 +4,20 @@ import li.cil.oc.api.machine.Arguments;
 import li.cil.oc.api.machine.Callback;
 import li.cil.oc.api.machine.Context;
 import li.cil.oc.api.network.ManagedEnvironment;
-import li.cil.oc.api.prefab.DriverTileEntity;
+import li.cil.oc.api.prefab.DriverSidedTileEntity;
 import li.cil.oc.integration.ManagedTileEntityEnvironment;
 import net.minecraft.world.World;
 import net.minecraftforge.common.util.ForgeDirection;
 import net.minecraftforge.fluids.IFluidHandler;
 
-public final class DriverFluidHandler extends DriverTileEntity {
+public final class DriverFluidHandler extends DriverSidedTileEntity {
     @Override
     public Class<?> getTileEntityClass() {
         return IFluidHandler.class;
     }
 
     @Override
-    public ManagedEnvironment createEnvironment(final World world, final int x, final int y, final int z) {
+    public ManagedEnvironment createEnvironment(final World world, final int x, final int y, final int z, final ForgeDirection side) {
         return new Environment((IFluidHandler) world.getTileEntity(x, y, z));
     }
 

src/main/scala/li/cil/oc/integration/vanilla/DriverFluidTank.java

@@ -4,19 +4,20 @@ import li.cil.oc.api.machine.Arguments;
 import li.cil.oc.api.machine.Callback;
 import li.cil.oc.api.machine.Context;
 import li.cil.oc.api.network.ManagedEnvironment;
-import li.cil.oc.api.prefab.DriverTileEntity;
+import li.cil.oc.api.prefab.DriverSidedTileEntity;
 import li.cil.oc.integration.ManagedTileEntityEnvironment;
 import net.minecraft.world.World;
+import net.minecraftforge.common.util.ForgeDirection;
 import net.minecraftforge.fluids.IFluidTank;
 
-public final class DriverFluidTank extends DriverTileEntity {
+public final class DriverFluidTank extends DriverSidedTileEntity {
     @Override
     public Class<?> getTileEntityClass() {
         return IFluidTank.class;
     }
 
     @Override
-    public ManagedEnvironment createEnvironment(final World world, final int x, final int y, final int z) {
+    public ManagedEnvironment createEnvironment(final World world, final int x, final int y, final int z, final ForgeDirection side) {
         return new Environment((IFluidTank) world.getTileEntity(x, y, z));
     }
 

src/main/scala/li/cil/oc/integration/vanilla/DriverFurnace.scala

@@ -6,7 +6,7 @@ import li.cil.oc.api.machine.Arguments
 import li.cil.oc.api.machine.Callback
 import li.cil.oc.api.machine.Context
 import li.cil.oc.api.network.ManagedEnvironment
-import li.cil.oc.api.prefab.DriverTileEntity
+import li.cil.oc.api.prefab.DriverSidedTileEntity
 import li.cil.oc.integration.ManagedTileEntityEnvironment
 import li.cil.oc.util.ResultWrapper.result
 import net.minecraft.block.Block
@@ -14,11 +14,12 @@ import net.minecraft.init.Blocks
 import net.minecraft.item.ItemStack
 import net.minecraft.tileentity.TileEntityFurnace
 import net.minecraft.world.World
+import net.minecraftforge.common.util.ForgeDirection
 
-object DriverFurnace extends DriverTileEntity {
+object DriverFurnace extends DriverSidedTileEntity {
   override def getTileEntityClass: Class[_] = classOf[TileEntityFurnace]
 
-  override def createEnvironment(world: World, x: Int, y: Int, z: Int): ManagedEnvironment =
+  override def createEnvironment(world: World, x: Int, y: Int, z: Int, side: ForgeDirection): ManagedEnvironment =
     new Environment(world.getTileEntity(x, y, z).asInstanceOf[TileEntityFurnace])
 
   final class Environment(tileEntity: TileEntityFurnace) extends ManagedTileEntityEnvironment[TileEntityFurnace](tileEntity, "furnace") with NamedBlock {

src/main/scala/li/cil/oc/integration/vanilla/DriverInventory.java

@@ -6,7 +6,7 @@ import li.cil.oc.api.machine.Arguments;
 import li.cil.oc.api.machine.Callback;
 import li.cil.oc.api.machine.Context;
 import li.cil.oc.api.network.ManagedEnvironment;
-import li.cil.oc.api.prefab.DriverTileEntity;
+import li.cil.oc.api.prefab.DriverSidedTileEntity;
 import li.cil.oc.integration.ManagedTileEntityEnvironment;
 import li.cil.oc.util.BlockPosition;
 import net.minecraft.entity.player.EntityPlayer;
@@ -16,17 +16,18 @@ import net.minecraft.tileentity.TileEntity;
 import net.minecraft.world.World;
 import net.minecraft.world.WorldServer;
 import net.minecraftforge.common.util.FakePlayerFactory;
+import net.minecraftforge.common.util.ForgeDirection;
 import net.minecraftforge.event.ForgeEventFactory;
 import net.minecraftforge.event.entity.player.PlayerInteractEvent;
 
-public final class DriverInventory extends DriverTileEntity {
+public final class DriverInventory extends DriverSidedTileEntity {
     @Override
     public Class<?> getTileEntityClass() {
         return IInventory.class;
     }
 
     @Override
-    public ManagedEnvironment createEnvironment(final World world, final int x, final int y, final int z) {
+    public ManagedEnvironment createEnvironment(final World world, final int x, final int y, final int z, final ForgeDirection side) {
         return new Environment(world.getTileEntity(x, y, z), world);
     }
 

src/main/scala/li/cil/oc/integration/vanilla/DriverMobSpawner.scala

@@ -6,7 +6,7 @@ import li.cil.oc.api.machine.Arguments
 import li.cil.oc.api.machine.Callback
 import li.cil.oc.api.machine.Context
 import li.cil.oc.api.network.ManagedEnvironment
-import li.cil.oc.api.prefab.DriverTileEntity
+import li.cil.oc.api.prefab.DriverSidedTileEntity
 import li.cil.oc.integration.ManagedTileEntityEnvironment
 import li.cil.oc.util.ResultWrapper.result
 import net.minecraft.block.Block
@@ -14,11 +14,12 @@ import net.minecraft.init.Blocks
 import net.minecraft.item.ItemStack
 import net.minecraft.tileentity.TileEntityMobSpawner
 import net.minecraft.world.World
+import net.minecraftforge.common.util.ForgeDirection
 
-object DriverMobSpawner extends DriverTileEntity {
+object DriverMobSpawner extends DriverSidedTileEntity {
   override def getTileEntityClass: Class[_] = classOf[TileEntityMobSpawner]
 
-  override def createEnvironment(world: World, x: Int, y: Int, z: Int): ManagedEnvironment =
+  override def createEnvironment(world: World, x: Int, y: Int, z: Int, side: ForgeDirection): ManagedEnvironment =
     new Environment(world.getTileEntity(x, y, z).asInstanceOf[TileEntityMobSpawner])
 
   final class Environment(tileEntity: TileEntityMobSpawner) extends ManagedTileEntityEnvironment[TileEntityMobSpawner](tileEntity, "mob_spawner") with NamedBlock {

src/main/scala/li/cil/oc/integration/vanilla/DriverNoteBlock.scala

@@ -6,7 +6,7 @@ import li.cil.oc.api.machine.Arguments
 import li.cil.oc.api.machine.Callback
 import li.cil.oc.api.machine.Context
 import li.cil.oc.api.network.ManagedEnvironment
-import li.cil.oc.api.prefab.DriverTileEntity
+import li.cil.oc.api.prefab.DriverSidedTileEntity
 import li.cil.oc.integration.ManagedTileEntityEnvironment
 import li.cil.oc.util.ResultWrapper.result
 import net.minecraft.block.Block
@@ -15,11 +15,12 @@ import net.minecraft.init.Blocks
 import net.minecraft.item.ItemStack
 import net.minecraft.tileentity.TileEntityNote
 import net.minecraft.world.World
+import net.minecraftforge.common.util.ForgeDirection
 
-object DriverNoteBlock extends DriverTileEntity {
+object DriverNoteBlock extends DriverSidedTileEntity {
   override def getTileEntityClass: Class[_] = classOf[TileEntityNote]
 
-  override def createEnvironment(world: World, x: Int, y: Int, z: Int): ManagedEnvironment =
+  override def createEnvironment(world: World, x: Int, y: Int, z: Int, side: ForgeDirection): ManagedEnvironment =
     new Environment(world.getTileEntity(x, y, z).asInstanceOf[TileEntityNote])
 
   final class Environment(tileEntity: TileEntityNote) extends ManagedTileEntityEnvironment[TileEntityNote](tileEntity, "note_block") with NamedBlock {

src/main/scala/li/cil/oc/integration/vanilla/DriverRecordPlayer.scala

@@ -6,7 +6,7 @@ import li.cil.oc.api.machine.Arguments
 import li.cil.oc.api.machine.Callback
 import li.cil.oc.api.machine.Context
 import li.cil.oc.api.network.ManagedEnvironment
-import li.cil.oc.api.prefab.DriverTileEntity
+import li.cil.oc.api.prefab.DriverSidedTileEntity
 import li.cil.oc.integration.ManagedTileEntityEnvironment
 import li.cil.oc.util.ResultWrapper.result
 import net.minecraft.block.Block
@@ -16,11 +16,12 @@ import net.minecraft.item.Item
 import net.minecraft.item.ItemRecord
 import net.minecraft.item.ItemStack
 import net.minecraft.world.World
+import net.minecraftforge.common.util.ForgeDirection
 
-object DriverRecordPlayer extends DriverTileEntity {
+object DriverRecordPlayer extends DriverSidedTileEntity {
   override def getTileEntityClass: Class[_] = classOf[BlockJukebox.TileEntityJukebox]
 
-  override def createEnvironment(world: World, x: Int, y: Int, z: Int): ManagedEnvironment = new Environment(world.getTileEntity(x, y, z).asInstanceOf[BlockJukebox.TileEntityJukebox])
+  override def createEnvironment(world: World, x: Int, y: Int, z: Int, side: ForgeDirection): ManagedEnvironment = new Environment(world.getTileEntity(x, y, z).asInstanceOf[BlockJukebox.TileEntityJukebox])
 
   final class Environment(tileEntity: BlockJukebox.TileEntityJukebox) extends ManagedTileEntityEnvironment[BlockJukebox.TileEntityJukebox](tileEntity, "jukebox") with NamedBlock {
     override def preferredName = "jukebox"