Added support for AE2 power, closes #508.

build.gradle

@@ -75,6 +75,7 @@ configurations {
 }
 
 dependencies {
+    provided "appeng:appliedenergistics2:${config.ae2.version}:dev"
     provided "codechicken:CodeChickenLib:${config.minecraft.version}-${config.ccl.version}:dev"
     provided "codechicken:ForgeMultipart:${config.minecraft.version}-${config.fmp.version}:dev"
     provided "codechicken:NotEnoughItems:${config.minecraft.version}-${config.nei.version}:dev"

build.properties

@@ -1,11 +1,12 @@
 minecraft.version=1.7.10
-forge.version=10.13.0.1180
+forge.version=10.13.0.1208
 oc.version=1.3.5
 oc.subversion=dev
-ccl.version=1.1.1.95
-fmp.version=1.1.0.299
-nei.version=1.0.3.51
+ccl.version=1.1.1.104
+fmp.version=1.1.0.307
+nei.version=1.0.3.56
 wrcbe.version=1.4.0.7
+ae2.version=+
 bc.version=6.0.18
 ic2.version=2.2.+
 maven.url=file:///var/www/users/fnuecke/maven.cil.li

src/main/resources/application.conf

@@ -642,6 +642,7 @@ opencomputers {
 
       # Power values for different power systems.
       value {
+          AppliedEnergistics2: 100.0
           BuildCraft: 500.0
           Factorization: 6.5
           Galacticraft: 24.0

src/main/scala/li/cil/oc/Settings.scala

@@ -168,6 +168,7 @@ class Settings(config: Config) {
   val pistonCost = config.getDouble("power.cost.pistonPush") max 0
 
   // power.value
+  private val valueAppliedEnergistics2 = config.getDouble("power.value.AppliedEnergistics2")
   private val valueBuildCraft = config.getDouble("power.value.BuildCraft")
   private val valueFactorization = config.getDouble("power.value.Factorization")
   private val valueGalacticraft = config.getDouble("power.value.Galacticraft")
@@ -178,6 +179,7 @@ class Settings(config: Config) {
 
   private val valueInternal = valueBuildCraft
 
+  val ratioAppliedEnergistics2 = valueAppliedEnergistics2 / valueInternal
   val ratioBuildCraft = valueBuildCraft / valueInternal
   val ratioFactorization = valueFactorization / valueInternal
   val ratioGalacticraft = valueGalacticraft / valueInternal

src/main/scala/li/cil/oc/common/EventHandler.scala

@@ -44,6 +44,15 @@ object EventHandler {
     }
   }
 
+  @Optional.Method(modid = Mods.IDs.UniversalElectricity)
+  def scheduleAE2Add(tileEntity: power.AppliedEnergistics2) {
+    if (SideTracker.isServer) pending.synchronized {
+      pending += (() => if (!tileEntity.isInvalid) {
+        tileEntity.getGridNode(ForgeDirection.UNKNOWN).updateState()
+      })
+    }
+  }
+
   @Optional.Method(modid = Mods.IDs.IndustrialCraft2)
   def scheduleIC2Add(tileEntity: power.IndustrialCraft2Experimental) {
     if (SideTracker.isServer) pending.synchronized {

src/main/scala/li/cil/oc/common/asm/ClassTransformer.scala

@@ -18,6 +18,7 @@ class ClassTransformer extends IClassTransformer {
   private val log = LogManager.getLogger("OpenComputers")
 
   private lazy val powerTypes = Map[Mod, Array[String]](
+    Mods.AppliedEnergistics2 -> Array("appeng/api/networking/IGridHost"),
     Mods.BuildCraftPower -> Array("buildcraft/api/power/IPowerReceptor"),
     Mods.Factorization -> Array("factorization/api/IChargeConductor"),
     Mods.Galacticraft -> Array("micdoodle8/mods/galacticraft/api/power/IEnergyHandlerGC"),

src/main/scala/li/cil/oc/common/tileentity/traits/PowerAcceptor.scala

@@ -2,6 +2,7 @@ package li.cil.oc.common.tileentity.traits
 
 trait PowerAcceptor
   extends power.Common
+  with power.AppliedEnergistics2
   with power.BuildCraft
   with power.Factorization
   with power.Galacticraft

src/main/scala/li/cil/oc/common/tileentity/traits/power/AppliedEnergistics2.scala

@@ -0,0 +1,128 @@
+package li.cil.oc.common.tileentity.traits.power
+
+import java.util
+
+import appeng.api.AEApi
+import appeng.api.config.{Actionable, PowerMultiplier}
+import appeng.api.networking._
+import appeng.api.networking.energy.IEnergyGrid
+import appeng.api.util.{AECableType, AEColor, DimensionalCoord}
+import cpw.mods.fml.common.Optional
+import li.cil.oc.Settings
+import li.cil.oc.common.EventHandler
+import li.cil.oc.util.mods.Mods
+import net.minecraft.nbt.NBTTagCompound
+import net.minecraftforge.common.util.ForgeDirection
+
+import scala.collection.convert.WrapAsJava._
+
+trait AppliedEnergistics2 extends Common {
+  private lazy val useAppliedEnergistics2Power = isServer && Mods.AppliedEnergistics2.isAvailable
+
+  // 'Manual' lazy val, because lazy vals mess up the class loader, leading to class not found exceptions.
+  private var node: Option[AnyRef] = None
+
+  override def updateEntity() {
+    super.updateEntity()
+    if (useAppliedEnergistics2Power && world.getTotalWorldTime % Settings.get.tickFrequency == 0) {
+      updateEnergy()
+    }
+  }
+
+  @Optional.Method(modid = Mods.IDs.AppliedEnergistics2)
+  private def updateEnergy() {
+    val grid = getGridNode(ForgeDirection.UNKNOWN).getGrid
+    if (grid != null) {
+      val cache = grid.getCache(classOf[IEnergyGrid]).asInstanceOf[IEnergyGrid]
+      if (cache != null) {
+        for (side <- ForgeDirection.VALID_DIRECTIONS) {
+          val demand = (globalBufferSize(side) - globalBuffer(side)) / Settings.get.ratioAppliedEnergistics2
+          if (demand > 1) {
+            val power = cache.extractAEPower(demand, Actionable.MODULATE, PowerMultiplier.CONFIG)
+            tryChangeBuffer(side, power * Settings.get.ratioAppliedEnergistics2)
+          }
+        }
+      }
+    }
+  }
+
+  override def validate() {
+    super.validate()
+    if (useAppliedEnergistics2Power) EventHandler.scheduleAE2Add(this)
+  }
+
+  override def invalidate() {
+    super.invalidate()
+    if (useAppliedEnergistics2Power) securityBreak()
+  }
+
+  override def onChunkUnload() {
+    super.onChunkUnload()
+    if (useAppliedEnergistics2Power) securityBreak()
+  }
+
+  // ----------------------------------------------------------------------- //
+
+  override def readFromNBT(nbt: NBTTagCompound) {
+    super.readFromNBT(nbt)
+    if (useAppliedEnergistics2Power) loadNode(nbt)
+  }
+
+  @Optional.Method(modid = Mods.IDs.AppliedEnergistics2)
+  private def loadNode(nbt: NBTTagCompound): Unit = {
+    getGridNode(ForgeDirection.UNKNOWN).loadFromNBT(Settings.namespace + "ae2power", nbt)
+  }
+
+  override def writeToNBT(nbt: NBTTagCompound) {
+    super.writeToNBT(nbt)
+    if (useAppliedEnergistics2Power) saveNode(nbt)
+  }
+
+  @Optional.Method(modid = Mods.IDs.AppliedEnergistics2)
+  private def saveNode(nbt: NBTTagCompound): Unit = {
+    getGridNode(ForgeDirection.UNKNOWN).saveToNBT(Settings.namespace + "ae2power", nbt)
+  }
+
+  // ----------------------------------------------------------------------- //
+
+  @Optional.Method(modid = Mods.IDs.AppliedEnergistics2)
+  def getGridNode(side: ForgeDirection) = node match {
+    case Some(gridNode: IGridNode) => gridNode
+    case _ =>
+      val gridNode = AEApi.instance.createGridNode(new AppliedEnergistics2GridBlock(this))
+      node = Option(gridNode)
+      gridNode
+  }
+
+  @Optional.Method(modid = Mods.IDs.AppliedEnergistics2)
+  def getCableConnectionType(side: ForgeDirection) = AECableType.SMART
+
+  @Optional.Method(modid = Mods.IDs.AppliedEnergistics2)
+  def securityBreak() {
+    getGridNode(ForgeDirection.UNKNOWN).destroy()
+  }
+}
+
+class AppliedEnergistics2GridBlock(val tileEntity: AppliedEnergistics2) extends IGridBlock {
+  override def getIdlePowerUsage = 0.0
+
+  override def getFlags = util.EnumSet.noneOf(classOf[GridFlags])
+
+  override def isWorldAccessable = true
+
+  override def getLocation = new DimensionalCoord(tileEntity)
+
+  override def getGridColor = AEColor.Transparent
+
+  override def onGridNotification(p1: GridNotification) {}
+
+  override def setNetworkStatus(p1: IGrid, p2: Int) {}
+
+  override def getConnectableSides = util.EnumSet.copyOf(ForgeDirection.VALID_DIRECTIONS.filter(tileEntity.canConnectPower).toList)
+
+  override def getMachine = tileEntity.asInstanceOf[IGridHost]
+
+  override def gridChanged() {}
+
+  override def getMachineRepresentation = null
+}

src/main/scala/li/cil/oc/common/tileentity/traits/power/BuildCraft.scala

@@ -2,8 +2,10 @@ package li.cil.oc.common.tileentity.traits.power
 
 import buildcraft.api.power.{IPowerReceptor, PowerHandler}
 import cpw.mods.fml.common.Optional
+import li.cil.oc.util.ExtendedNBT._
 import li.cil.oc.util.mods.Mods
 import li.cil.oc.{OpenComputers, Settings}
+import net.minecraft.nbt.NBTTagCompound
 import net.minecraftforge.common.util.ForgeDirection
 
 trait BuildCraft extends Common {
@@ -16,18 +18,45 @@ trait BuildCraft extends Common {
   override def updateEntity() {
     super.updateEntity()
     if (useBuildCraftPower && world.getTotalWorldTime % Settings.get.tickFrequency == 0) {
-      for (side <- ForgeDirection.VALID_DIRECTIONS) {
-        val demand = (globalBufferSize(side) - globalBuffer(side)) / Settings.get.ratioBuildCraft
-        if (demand > 1) {
-          val power = getPowerProvider.useEnergy(1, demand.toFloat, true)
-          tryChangeBuffer(side, power * Settings.get.ratioBuildCraft)
-        }
+      updateEnergy()
+    }
+  }
+
+  @Optional.Method(modid = Mods.IDs.BuildCraftPower)
+  private def updateEnergy() {
+    for (side <- ForgeDirection.VALID_DIRECTIONS) {
+      val demand = (globalBufferSize(side) - globalBuffer(side)) / Settings.get.ratioBuildCraft
+      if (demand > 1) {
+        val power = getPowerProvider.useEnergy(1, demand.toFloat, true)
+        tryChangeBuffer(side, power * Settings.get.ratioBuildCraft)
       }
     }
   }
 
   // ----------------------------------------------------------------------- //
 
+  override def readFromNBT(nbt: NBTTagCompound) {
+    super.readFromNBT(nbt)
+    if (useBuildCraftPower) loadHandler(nbt)
+  }
+
+  @Optional.Method(modid = Mods.IDs.BuildCraftPower)
+  private def loadHandler(nbt: NBTTagCompound): Unit = {
+    Option(getPowerProvider).foreach(_.readFromNBT(nbt.getCompoundTag(Settings.namespace + "bcpower")))
+  }
+
+  override def writeToNBT(nbt: NBTTagCompound) {
+    super.writeToNBT(nbt)
+    if (useBuildCraftPower) saveHandler(nbt)
+  }
+
+  @Optional.Method(modid = Mods.IDs.BuildCraftPower)
+  private def saveHandler(nbt: NBTTagCompound): Unit = {
+    Option(getPowerProvider).foreach(h => nbt.setNewCompoundTag(Settings.namespace + "bcpower", h.writeToNBT))
+  }
+
+  // ----------------------------------------------------------------------- //
+
   @Optional.Method(modid = Mods.IDs.BuildCraftPower)
   def getPowerProvider = {
     if (Mods.BuildCraftPower.isAvailable && powerHandler.isEmpty) {

src/main/scala/li/cil/oc/util/mods/Mods.scala

@@ -9,6 +9,7 @@ import scala.collection.mutable
 object Mods {
 
   object IDs {
+    final val AppliedEnergistics2 = "appliedenergistics2"
     final val BattleGear2 = "battlegear2"
     final val BuildCraftPower = "BuildCraftAPI|power"
     final val ComputerCraft = "ComputerCraft"
@@ -41,6 +42,7 @@ object Mods {
 
   lazy val isPowerProvidingModPresent = knownMods.exists(mod => mod.providesPower && mod.isAvailable)
 
+  val AppliedEnergistics2 = new SimpleMod(IDs.AppliedEnergistics2)
   val BattleGear2 = new SimpleMod(IDs.BattleGear2)
   val BuildCraftPower = new SimpleMod(IDs.BuildCraftPower, providesPower = true)
   val ComputerCraft = new SimpleMod(IDs.ComputerCraft)