added @Optional for ic2, bc and cc interfaces

li/cil/oc/common/tileentity/Adapter.scala

@@ -1,5 +1,6 @@
 package li.cil.oc.common.tileentity
 
+import cpw.mods.fml.common.{Loader, Optional}
 import dan200.computer.api.{ILuaContext, IComputerAccess, IPeripheral}
 import li.cil.oc.api
 import li.cil.oc.api.Network
@@ -7,10 +8,11 @@ import li.cil.oc.api.network._
 import li.cil.oc.server.driver
 import net.minecraft.nbt.{NBTTagList, NBTTagCompound}
 import net.minecraftforge.common.ForgeDirection
-import scala.Some
 import scala.collection.convert.WrapAsScala._
 import scala.collection.mutable
+import scala.{Array, Some}
 
+@Optional.Interface(iface = "dan200.computer.api.IPeripheral", modid = "ComputerCraft")
 class Adapter extends Rotatable with Environment with IPeripheral {
   val node = api.Network.newNode(this, Visibility.Network).create()
 
@@ -73,10 +75,11 @@ class Adapter extends Rotatable with Environment with IPeripheral {
   // ----------------------------------------------------------------------- //
 
   @LuaCallback("send")
+  @Optional.Method(modid = "ComputerCraft")
   def send(context: Context, args: Arguments) = {
     val port = args.checkInteger(0)
     val answerPort = args.checkInteger(1)
-    for ((computer, ports) <- openPorts if ports.contains(port)) {
+    for ((computer: IComputerAccess, ports) <- openPorts if ports.contains(port)) {
       computer.queueEvent("modem_message", Array(Seq(computer.getAttachmentName, Int.box(port), Int.box(answerPort)) ++ args.drop(2): _*))
     }
     null
@@ -93,16 +96,18 @@ class Adapter extends Rotatable with Environment with IPeripheral {
 
   override def onMessage(message: Message) {
     super.onMessage(message)
-    if (message.name == "network.message") message.data match {
+    if (Loader.isModLoaded("ComputerCraft")) {
-      case Array(port: Integer, answerPort: java.lang.Double, args@_*) =>
+      if (message.name == "network.message") message.data match {
-        for (computer <- computers) {
+        case Array(port: Integer, answerPort: java.lang.Double, args@_*) =>
-          if (openPorts(computer).contains(port))
+          for (computer <- computers.map(_.asInstanceOf[IComputerAccess])) {
-            computer.queueEvent("modem_message", Array(Seq(computer.getAttachmentName, Int.box(port), Int.box(answerPort.toInt)) ++ args.map {
+            if (openPorts(computer).contains(port))
-              case x: Array[Byte] => new String(x, "UTF-8")
+              computer.queueEvent("modem_message", Array(Seq(computer.getAttachmentName, Int.box(port), Int.box(answerPort.toInt)) ++ args.map {
-              case x => x
+                case x: Array[Byte] => new String(x, "UTF-8")
-            }: _*))
+                case x => x
-        }
+              }: _*))
-      case _ =>
+          }
+        case _ =>
+      }
     }
   }
 
@@ -149,24 +154,29 @@ class Adapter extends Rotatable with Environment with IPeripheral {
 
   // ----------------------------------------------------------------------- //
 
-  private val computers = mutable.ArrayBuffer.empty[IComputerAccess]
+  private val computers = mutable.ArrayBuffer.empty[AnyRef]
 
-  private val openPorts = mutable.Map.empty[IComputerAccess, mutable.Set[Int]]
+  private val openPorts = mutable.Map.empty[AnyRef, mutable.Set[Int]]
 
+  @Optional.Method(modid = "ComputerCraft")
   override def getType = "oc_adapter"
 
+  @Optional.Method(modid = "ComputerCraft")
   override def attach(computer: IComputerAccess) {
     computers += computer
     openPorts += computer -> mutable.Set.empty
   }
 
+  @Optional.Method(modid = "ComputerCraft")
   override def detach(computer: IComputerAccess) {
     computers -= computer
     openPorts -= computer
   }
 
+  @Optional.Method(modid = "ComputerCraft")
   override def getMethodNames = Array("open", "isOpen", "close", "closeAll", "transmit", "isWireless")
 
+  @Optional.Method(modid = "ComputerCraft")
   override def callMethod(computer: IComputerAccess, context: ILuaContext, method: Int, arguments: Array[AnyRef]) = getMethodNames()(method) match {
     case "open" =>
       val port = checkPort(arguments, 0)
@@ -191,6 +201,7 @@ class Adapter extends Rotatable with Environment with IPeripheral {
     case _ => null
   }
 
+  @Optional.Method(modid = "ComputerCraft")
   override def canAttachToSide(side: Int) = true
 
   private def checkPort(args: Array[AnyRef], index: Int) = {

li/cil/oc/common/tileentity/PowerConverter.scala

@@ -1,6 +1,7 @@
 package li.cil.oc.common.tileentity
 
 import buildcraft.api.power.{PowerHandler, IPowerReceptor}
+import cpw.mods.fml.common.{Loader, Optional}
 import ic2.api.energy.event.{EnergyTileLoadEvent, EnergyTileUnloadEvent}
 import ic2.api.energy.tile.IEnergySink
 import li.cil.oc.api.Network
@@ -12,17 +13,14 @@ import net.minecraftforge.common.{ForgeDirection, MinecraftForge}
 import universalelectricity.core.block.IElectrical
 import universalelectricity.core.electricity.ElectricityPack
 
+@Optional.InterfaceList(Array(
+  new Optional.Interface(iface = "ic2.api.energy.tile.IEnergySink", modid = "IC2"),
+  new Optional.Interface(iface = "buildcraft.api.power.IPowerReceptor", modid = "BuildCraft|Energy")))
 class PowerConverter extends Rotatable with Environment with IEnergySink with IPowerReceptor with IElectrical {
   val node = api.Network.newNode(this, Visibility.Network).
     withConnector(Config.bufferConverter).
     create()
 
-  private var addedToEnet = false
-
-  private var lastPacketSize = 0.0
-
-  private var powerHandler: PowerHandler = null
-
   private def demand = node.bufferSize - node.buffer
 
   // ----------------------------------------------------------------------- //
@@ -42,11 +40,10 @@ class PowerConverter extends Rotatable with Environment with IEnergySink with IP
       Network.joinOrCreateNetwork(worldObj, xCoord, yCoord, zCoord)
     }
     if (!worldObj.isRemote) {
-      if (!addedToEnet) {
+      if (Loader.isModLoaded("IC2")) {
-        MinecraftForge.EVENT_BUS.post(new EnergyTileLoadEvent(this))
+        loadIC2()
-        addedToEnet = true
       }
-      if (demand > 0) {
+      if (demand > 0 && Loader.isModLoaded("BuildCraft|Energy")) {
         node.changeBuffer(getPowerProvider.useEnergy(1, demand.toFloat / ratioBuildCraft, true) * ratioBuildCraft)
       }
     }
@@ -58,9 +55,8 @@ class PowerConverter extends Rotatable with Environment with IEnergySink with IP
   }
 
   def unload() {
-    if (addedToEnet) {
+    if (Loader.isModLoaded("IC2")) {
-      MinecraftForge.EVENT_BUS.post(new EnergyTileUnloadEvent(this))
+      unloadIC2()
-      addedToEnet = false
     }
   }
 
@@ -69,23 +65,49 @@ class PowerConverter extends Rotatable with Environment with IEnergySink with IP
   override def readFromNBT(nbt: NBTTagCompound) {
     super.readFromNBT(nbt)
     if (node != null) node.load(nbt)
-    getPowerProvider.readFromNBT(nbt)
 
+    if (Loader.isModLoaded("BuildCraft|Energy"))
+      getPowerProvider.readFromNBT(nbt)
   }
 
   override def writeToNBT(nbt: NBTTagCompound) {
     super.writeToNBT(nbt)
     if (node != null) node.save(nbt)
-    getPowerProvider.writeToNBT(nbt)
+
+    if (Loader.isModLoaded("BuildCraft|Energy"))
+      getPowerProvider.writeToNBT(nbt)
   }
 
   // ----------------------------------------------------------------------- //
   // IndustrialCraft
 
+  private var isIC2Loaded = false
+
+  private var lastPacketSize = 0.0
+
+  @Optional.Method(modid = "IC2")
+  def loadIC2() {
+    if (!isIC2Loaded) {
+      MinecraftForge.EVENT_BUS.post(new EnergyTileLoadEvent(this))
+      isIC2Loaded = true
+    }
+  }
+
+  @Optional.Method(modid = "IC2")
+  def unloadIC2() {
+    if (isIC2Loaded) {
+      MinecraftForge.EVENT_BUS.post(new EnergyTileUnloadEvent(this))
+      isIC2Loaded = false
+    }
+  }
+
+  @Optional.Method(modid = "IC2")
   override def acceptsEnergyFrom(emitter: TileEntity, direction: ForgeDirection) = true
 
+  @Optional.Method(modid = "IC2")
   override def getMaxSafeInput = Integer.MAX_VALUE
 
+  @Optional.Method(modid = "IC2")
   override def demandedEnergyUnits = {
     // We try to avoid requesting energy when we need less than what we get with
     // a single packet. However, if our buffer gets dangerously low we will ask
@@ -95,6 +117,7 @@ class PowerConverter extends Rotatable with Environment with IEnergySink with IP
     } else 0
   }
 
+  @Optional.Method(modid = "IC2")
   override def injectEnergyUnits(directionFrom: ForgeDirection, amount: Double) = {
     lastPacketSize = amount
     node.changeBuffer(amount * ratioIndustrialCraft)
@@ -104,24 +127,31 @@ class PowerConverter extends Rotatable with Environment with IEnergySink with IP
   // ----------------------------------------------------------------------- //
   // BuildCraft
 
+  private var powerHandler: Option[AnyRef] = None
+
+  @Optional.Method(modid = "BuildCraft|Energy")
   def getPowerProvider = {
-    if (node != null && powerHandler == null) {
+    if (node != null && powerHandler.isEmpty) {
-      powerHandler = new PowerHandler(this, PowerHandler.Type.STORAGE)
+      val handler = new PowerHandler(this, PowerHandler.Type.STORAGE)
-      if (powerHandler != null) {
+      if (handler != null) {
-        powerHandler.configure(1, 320, Float.MaxValue, node.bufferSize.toFloat / ratioBuildCraft)
+        handler.configure(1, 320, Float.MaxValue, node.bufferSize.toFloat / ratioBuildCraft)
-        powerHandler.configurePowerPerdition(0, 0)
+        handler.configurePowerPerdition(0, 0)
+        powerHandler = Some(handler)
       }
     }
-    powerHandler
+    powerHandler.fold(null: PowerHandler)(_.asInstanceOf[PowerHandler])
   }
 
+  @Optional.Method(modid = "BuildCraft|Energy")
   def getPowerReceiver(side: ForgeDirection) =
     if (node != null)
       getPowerProvider.getPowerReceiver
     else null
 
+  @Optional.Method(modid = "BuildCraft|Energy")
   def getWorld = worldObj
 
+  @Optional.Method(modid = "BuildCraft|Energy")
   def doWork(workProvider: PowerHandler) {}
 
   // ----------------------------------------------------------------------- //