Merge branch 'master-MC1.7.10' of github.com:MightyPirates/OpenComputers into master-MC1.8

src/main/resources/assets/opencomputers/loot/OpenOS/bin/cat.lua

@@ -21,5 +21,6 @@ else
         io.write(line)
       end
     until not line
+    file:close()
   end
-end
+end

src/main/scala/li/cil/oc/integration/Mod.java

@@ -3,7 +3,7 @@ package li.cil.oc.integration;
 public interface Mod {
     String id();
 
-    boolean isAvailable();
+    boolean isModAvailable();
 
     boolean providesPower();
 }

src/main/scala/li/cil/oc/integration/Mods.scala

@@ -56,10 +56,12 @@ object Mods {
   val StargateTech2 = new ModBase {
     def id = IDs.StargateTech2
 
-    protected override lazy val isModAvailable = Loader.isModLoaded(IDs.StargateTech2) && {
+    private lazy val isModAvailable_ = Loader.isModLoaded(IDs.StargateTech2) && {
       val mod = Loader.instance.getIndexedModList.get(IDs.StargateTech2)
       mod.getVersion.startsWith("0.7.")
     }
+
+    override def isModAvailable: Boolean = isModAvailable_
   }
   val Thaumcraft = new SimpleMod(IDs.Thaumcraft)
   val ThermalExpansion = new SimpleMod(IDs.ThermalExpansion, providesPower = true)
@@ -121,7 +123,7 @@ object Mods {
   private def tryInit(mod: ModProxy) {
     val isBlacklisted = Settings.get.modBlacklist.contains(mod.getMod.id)
     val alwaysEnabled = mod.getMod == null || mod.getMod == Mods.Minecraft
-    if (!isBlacklisted && (alwaysEnabled || mod.getMod.isAvailable) && handlers.add(mod)) {
+    if (!isBlacklisted && (alwaysEnabled || mod.getMod.isModAvailable) && handlers.add(mod)) {
       li.cil.oc.OpenComputers.log.info(s"Initializing mod integration for '${mod.getMod.id}'.")
       try mod.initialize() catch {
         case e: Throwable =>
@@ -188,7 +190,7 @@ object Mods {
 
     protected lazy val isPowerModEnabled = !providesPower || (!Settings.get.pureIgnorePower && !Settings.get.powerModBlacklist.contains(id))
 
-    protected def isModAvailable: Boolean
+    def isModAvailable: Boolean
 
     def id: String
 
@@ -206,18 +208,22 @@ object Mods {
   }
 
   class SimpleMod(val id: String, override val providesPower: Boolean = false, version: String = "") extends ModBase {
-    override protected lazy val isModAvailable = {
+    private lazy val isModAvailable_ = {
       val version = VersionParser.parseVersionReference(id + this.version)
       if (Loader.isModLoaded(version.getLabel))
         version.containsVersion(Loader.instance.getIndexedModList.get(version.getLabel).getProcessedVersion)
       else ModAPIManager.INSTANCE.hasAPI(version.getLabel)
     }
+
+    def isModAvailable = isModAvailable_
   }
 
   class ClassBasedMod(val id: String, val classNames: String*)(override val providesPower: Boolean = false) extends ModBase {
-    override protected lazy val isModAvailable = classNames.forall(className => try Class.forName(className) != null catch {
+    private lazy val isModAvailable_ = classNames.forall(className => try Class.forName(className) != null catch {
       case _: Throwable => false
     })
+
+    def isModAvailable = isModAvailable_
   }
 
 }

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

@@ -11,6 +11,8 @@ import appeng.me.helpers.IGridProxyable
 import appeng.tile.misc.TileInterface
 import appeng.util.item.AEItemStack
 import com.google.common.collect.ImmutableSet
+import cpw.mods.fml.common.Loader
+import cpw.mods.fml.common.versioning.VersionRange
 import li.cil.oc.OpenComputers
 import li.cil.oc.api.driver.EnvironmentAware
 import li.cil.oc.api.driver.NamedBlock
@@ -22,6 +24,7 @@ import li.cil.oc.api.prefab.AbstractValue
 import li.cil.oc.api.prefab.DriverTileEntity
 import li.cil.oc.common.EventHandler
 import li.cil.oc.integration.ManagedTileEntityEnvironment
+import li.cil.oc.integration.Mods
 import li.cil.oc.util.ExtendedNBT._
 import li.cil.oc.util.ResultWrapper._
 import net.minecraft.block.Block
@@ -44,8 +47,16 @@ import scala.language.existentials
 object DriverController extends DriverTileEntity with EnvironmentAware {
   private type AETile = TileEntity with IGridProxyable with IActionHost
 
+  val versionsWithNewItemDefinitionAPI = VersionRange.createFromVersionSpec("[rv2-beta-20,)")
+
   def getTileEntityClass: Class[_] = {
-    if (AEApi.instance != null && AEApi.instance.blocks != null) {
+    if (versionsWithNewItemDefinitionAPI.containsVersion(Loader.instance.getIndexedModList.get(Mods.AppliedEnergistics2.id).getProcessedVersion)) {
+      if (AEApi.instance.definitions.blocks.controller.maybeStack(0).isPresent)
+        AEApi.instance.definitions.blocks.controller.maybeEntity.orNull
+      else
+        AEApi.instance.definitions.blocks.iface.maybeEntity.orNull
+    }
+    else if (AEApi.instance != null && AEApi.instance.blocks != null) {
       if (AEApi.instance.blocks.blockController != null && AEApi.instance.blocks.blockController.item != null)
         // Not classOf[TileController] because that derps the compiler when it tries to resolve the class (says can't find API classes from RotaryCraft).
         Class.forName("appeng.tile.networking.TileController")

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

@@ -0,0 +1,52 @@
+package li.cil.oc.integration.cofh.energy;
+
+import cofh.api.energy.IEnergyProvider;
+import cofh.api.energy.IEnergyReceiver;
+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.integration.ManagedTileEntityEnvironment;
+import net.minecraft.world.World;
+import net.minecraftforge.common.util.ForgeDirection;
+
+public final class DriverEnergyProvider extends DriverTileEntity {
+    @Override
+    public Class<?> getTileEntityClass() {
+        return IEnergyProvider.class;
+    }
+
+    @Override
+    public ManagedEnvironment createEnvironment(final World world, final int x, final int y, final int z) {
+        return new Environment((IEnergyProvider) world.getTileEntity(x, y, z));
+    }
+
+    public static final class Environment extends ManagedTileEntityEnvironment<IEnergyProvider> {
+        public Environment(final IEnergyProvider tileEntity) {
+            super(tileEntity, "energy_handler");
+        }
+
+        @Callback(doc = "function([direction:number=6]):number -- Returns the amount of stored energy for the given side.")
+        public Object[] getEnergyStored(final Context context, final Arguments args) {
+            final ForgeDirection side = args.count() > 0 ? ForgeDirection.getOrientation(args.checkInteger(0)) : ForgeDirection.UNKNOWN;
+            return new Object[]{tileEntity.getEnergyStored(side)};
+        }
+
+        @Callback(doc = "function([direction:number=6]):number -- Returns the maximum amount of stored energy for the given side.")
+        public Object[] getMaxEnergyStored(final Context context, final Arguments args) {
+            final ForgeDirection side = args.count() > 0 ? ForgeDirection.getOrientation(args.checkInteger(0)) : ForgeDirection.UNKNOWN;
+            return new Object[]{tileEntity.getMaxEnergyStored(side)};
+        }
+
+        @Callback(doc = "function():number -- Returns whether this component can provide energy.")
+        public Object[] isEnergyProvider(final Context context, final Arguments args) {
+            return new Object[]{true};
+        }
+
+        @Callback(doc = "function():number -- Returns whether this component can receive energy.")
+        public Object[] isEnergyReceiver(final Context context, final Arguments args) {
+            return new Object[]{tileEntity instanceof IEnergyReceiver};
+        }
+    }
+}

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

@@ -0,0 +1,57 @@
+package li.cil.oc.integration.cofh.energy;
+
+import cofh.api.energy.IEnergyProvider;
+import cofh.api.energy.IEnergyReceiver;
+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.integration.ManagedTileEntityEnvironment;
+import net.minecraft.world.World;
+import net.minecraftforge.common.util.ForgeDirection;
+
+public final class DriverEnergyReceiver extends DriverTileEntity {
+    @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);
+    }
+
+    @Override
+    public ManagedEnvironment createEnvironment(final World world, final int x, final int y, final int z) {
+        return new Environment((IEnergyReceiver) world.getTileEntity(x, y, z));
+    }
+
+    public static final class Environment extends ManagedTileEntityEnvironment<IEnergyReceiver> {
+        public Environment(final IEnergyReceiver tileEntity) {
+            super(tileEntity, "energy_handler");
+        }
+
+        @Callback(doc = "function([direction:number=6]):number -- Returns the amount of stored energy for the given side.")
+        public Object[] getEnergyStored(final Context context, final Arguments args) {
+            final ForgeDirection side = args.count() > 0 ? ForgeDirection.getOrientation(args.checkInteger(0)) : ForgeDirection.UNKNOWN;
+            return new Object[]{tileEntity.getEnergyStored(side)};
+        }
+
+        @Callback(doc = "function([direction:number=6]):number -- Returns the maximum amount of stored energy for the given side.")
+        public Object[] getMaxEnergyStored(final Context context, final Arguments args) {
+            final ForgeDirection side = args.count() > 0 ? ForgeDirection.getOrientation(args.checkInteger(0)) : ForgeDirection.UNKNOWN;
+            return new Object[]{tileEntity.getMaxEnergyStored(side)};
+        }
+
+        @Callback(doc = "function():number -- Returns whether this component can provide energy.")
+        public Object[] isEnergyProvider(final Context context, final Arguments args) {
+            return new Object[]{false};
+        }
+
+        @Callback(doc = "function():number -- Returns whether this component can receive energy.")
+        public Object[] isEnergyReceiver(final Context context, final Arguments args) {
+            return new Object[]{true};
+        }
+    }
+}

src/main/scala/li/cil/oc/integration/cofh/energy/ModCoFHEnergy.scala

@@ -1,20 +1,33 @@
 package li.cil.oc.integration.cofh.energy
 
+import cpw.mods.fml.common.ModAPIManager
 import cpw.mods.fml.common.event.FMLInterModComms
+import cpw.mods.fml.common.versioning.VersionRange
 import li.cil.oc.api.Driver
 import li.cil.oc.integration.ModProxy
 import li.cil.oc.integration.Mods
 import net.minecraftforge.common.MinecraftForge
 
+import scala.collection.convert.WrapAsScala._
+
 object ModCoFHEnergy extends ModProxy {
   override def getMod = Mods.CoFHEnergy
 
+  private val versionsUsingSplitEnergyAPI = VersionRange.createFromVersionSpec("[1.0.0,)")
+
   override def initialize() {
     FMLInterModComms.sendMessage(Mods.IDs.OpenComputers, "registerToolDurabilityProvider", "li.cil.oc.integration.cofh.energy.EventHandlerRedstoneFlux.getDurability")
 
     MinecraftForge.EVENT_BUS.register(EventHandlerRedstoneFlux)
 
-    Driver.add(new DriverEnergyHandler)
+    val apiVersion = ModAPIManager.INSTANCE.getAPIList.find(_.getModId == Mods.IDs.CoFHEnergy).map(_.getProcessedVersion)
+    if (apiVersion.exists(versionsUsingSplitEnergyAPI.containsVersion)) {
+      Driver.add(new DriverEnergyProvider)
+      Driver.add(new DriverEnergyReceiver)
+    }
+    else {
+      Driver.add(new DriverEnergyHandler)
+    }
 
     Driver.add(new ConverterEnergyContainerItem)
   }