Cleaned up wireless redstone integration logic, fixed SVE.

src/main/scala/li/cil/oc/common/item/RedstoneCard.scala

@@ -31,7 +31,7 @@ class RedstoneCard(val parent: Delegator, val tier: Int) extends Delegate with I
       if (Mods.WirelessRedstoneCBE.isAvailable) {
         tooltip.addAll(Tooltip.get(super.unlocalizedName + ".WirelessCBE"))
       }
-      if (Mods.WirelessRedstoneSV.isAvailable) {
+      if (Mods.WirelessRedstoneSVE.isAvailable) {
         tooltip.addAll(Tooltip.get(super.unlocalizedName + ".WirelessSV"))
       }
     }

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

@@ -4,30 +4,7 @@ import cpw.mods.fml.common.Loader
 import cpw.mods.fml.common.ModAPIManager
 import cpw.mods.fml.common.versioning.VersionParser
 import li.cil.oc.Settings
-import li.cil.oc.integration.appeng.ModAppEng
-import li.cil.oc.integration.buildcraft.ModBuildCraft
-import li.cil.oc.integration.cofh.energy.ModCoFHEnergy
-import li.cil.oc.integration.cofh.tileentity.ModCoFHTileEntity
-import li.cil.oc.integration.cofh.transport.ModCoFHTransport
-import li.cil.oc.integration.computercraft.ModComputerCraft
-import li.cil.oc.integration.enderio.ModEnderIO
-import li.cil.oc.integration.enderstorage.ModEnderStorage
-import li.cil.oc.integration.fmp.ModForgeMultipart
-import li.cil.oc.integration.forestry.ModForestry
-import li.cil.oc.integration.gregtech.ModGregtech
-import li.cil.oc.integration.ic2.ModIndustrialCraft2
-import li.cil.oc.integration.mfr.ModMineFactoryReloaded
-import li.cil.oc.integration.mystcraft.ModMystcraft
-import li.cil.oc.integration.opencomputers.ModOpenComputers
-import li.cil.oc.integration.railcraft.ModRailcraft
-import li.cil.oc.integration.tcon.ModTinkersConstruct
-import li.cil.oc.integration.thaumcraft.ModThaumcraft
-import li.cil.oc.integration.thermalexpansion.ModThermalExpansion
-import li.cil.oc.integration.tmechworks.ModTMechworks
-import li.cil.oc.integration.ue.ModUniversalElectricity
-import li.cil.oc.integration.vanilla.ModVanilla
-import li.cil.oc.integration.versionchecker.ModVersionChecker
-import li.cil.oc.integration.waila.ModWaila
+import li.cil.oc.integration
 
 import scala.collection.mutable
 
@@ -90,42 +67,44 @@ object Mods {
   val VersionChecker = new SimpleMod(IDs.VersionChecker)
   val Waila = new SimpleMod(IDs.Waila)
   val WirelessRedstoneCBE = new SimpleMod(IDs.WirelessRedstoneCBE)
-  val WirelessRedstoneSV = new SimpleMod(IDs.WirelessRedstoneSV)
+  val WirelessRedstoneSVE = new SimpleMod(IDs.WirelessRedstoneSV)
 
   // ----------------------------------------------------------------------- //
 
   def init() {
-    integrate(ModAppEng)
-    integrate(ModBuildCraft)
-    integrate(ModCoFHEnergy)
-    integrate(ModCoFHTileEntity)
-    integrate(ModCoFHTransport)
-    integrate(ModEnderIO)
-    integrate(ModEnderStorage)
-    integrate(ModForestry)
-    integrate(ModForgeMultipart)
-    integrate(ModGregtech)
-    integrate(ModIndustrialCraft2)
-    integrate(ModMineFactoryReloaded)
-    integrate(ModMystcraft)
-    integrate(ModOpenComputers)
-    integrate(ModRailcraft)
-    integrate(ModThaumcraft)
-    integrate(ModThermalExpansion)
-    integrate(ModTinkersConstruct)
-    integrate(ModTMechworks)
-    integrate(ModUniversalElectricity)
-    integrate(ModVanilla)
-    integrate(ModVersionChecker)
-    integrate(ModWaila)
+    tryInit(integration.appeng.ModAppEng)
+    tryInit(integration.buildcraft.ModBuildCraft)
+    tryInit(integration.cofh.energy.ModCoFHEnergy)
+    tryInit(integration.cofh.tileentity.ModCoFHTileEntity)
+    tryInit(integration.cofh.transport.ModCoFHTransport)
+    tryInit(integration.enderio.ModEnderIO)
+    tryInit(integration.enderstorage.ModEnderStorage)
+    tryInit(integration.forestry.ModForestry)
+    tryInit(integration.fmp.ModForgeMultipart)
+    tryInit(integration.gregtech.ModGregtech)
+    tryInit(integration.ic2.ModIndustrialCraft2)
+    tryInit(integration.mfr.ModMineFactoryReloaded)
+    tryInit(integration.mystcraft.ModMystcraft)
+    tryInit(integration.opencomputers.ModOpenComputers)
+    tryInit(integration.railcraft.ModRailcraft)
+    tryInit(integration.thaumcraft.ModThaumcraft)
+    tryInit(integration.thermalexpansion.ModThermalExpansion)
+    tryInit(integration.tcon.ModTinkersConstruct)
+    tryInit(integration.tmechworks.ModTMechworks)
+    tryInit(integration.ue.ModUniversalElectricity)
+    tryInit(integration.vanilla.ModVanilla)
+    tryInit(integration.versionchecker.ModVersionChecker)
+    tryInit(integration.waila.ModWaila)
+    tryInit(integration.wrcbe.ModWRCBE)
+    tryInit(integration.wrsve.ModWRSVE)
 
     // Register the general IPeripheral driver last, if at all, to avoid it
     // being used rather than other more concrete implementations, such as
     // is the case in the Redstone in Motion driver (replaces 'move').
-    integrate(ModComputerCraft)
+    tryInit(integration.computercraft.ModComputerCraft)
   }
 
-  private def integrate(mod: ModProxy) {
+  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)) {

src/main/scala/li/cil/oc/integration/util/WirelessRedstone.scala

@@ -1,31 +1,42 @@
 package li.cil.oc.integration.util
 
-import li.cil.oc.integration.Mods
 import li.cil.oc.server.component.RedstoneWireless
 
+import scala.collection.mutable
+
 object WirelessRedstone {
-  def isAvailable = Mods.WirelessRedstoneCBE.isAvailable ||
-    Mods.WirelessRedstoneSV.isAvailable
+  val systems = mutable.Set.empty[WirelessRedstoneSystem]
+
+  def isAvailable = systems.size > 0
 
   def addReceiver(rs: RedstoneWireless) {
-    WirelessRedstoneCBE.addReceiver(rs)
-    WirelessRedstoneSV.addReceiver(rs)
+    systems.foreach(_.addReceiver(rs))
   }
 
   def removeReceiver(rs: RedstoneWireless) {
-    WirelessRedstoneCBE.removeReceiver(rs)
-    WirelessRedstoneSV.removeReceiver(rs)
-  }
-
-  def removeTransmitter(rs: RedstoneWireless) {
-    WirelessRedstoneCBE.removeTransmitter(rs)
-    WirelessRedstoneSV.removeTransmitter(rs)
+    systems.foreach(_.removeReceiver(rs))
   }
 
   def updateOutput(rs: RedstoneWireless) {
-    WirelessRedstoneCBE.updateOutput(rs)
-    WirelessRedstoneSV.updateOutput(rs)
+    systems.foreach(_.updateOutput(rs))
+  }
+
+  def removeTransmitter(rs: RedstoneWireless) {
+    systems.foreach(_.removeTransmitter(rs))
+  }
+
+  def getInput(rs: RedstoneWireless) = systems.exists(_.getInput(rs))
+
+  trait WirelessRedstoneSystem {
+    def addReceiver(rs: RedstoneWireless)
+
+    def removeReceiver(rs: RedstoneWireless)
+
+    def updateOutput(rs: RedstoneWireless)
+
+    def removeTransmitter(rs: RedstoneWireless)
+
+    def getInput(rs: RedstoneWireless): Boolean
   }
 
-  def getInput(rs: RedstoneWireless) = WirelessRedstoneCBE.getInput(rs) || WirelessRedstoneSV.getInput(rs)
 }

src/main/scala/li/cil/oc/integration/util/WirelessRedstoneCBE.scala

@@ -1,60 +0,0 @@
-package li.cil.oc.integration.util
-
-import codechicken.wirelessredstone.core.WirelessReceivingDevice
-import codechicken.wirelessredstone.core.WirelessTransmittingDevice
-import li.cil.oc.server.component.RedstoneWireless
-
-import scala.language.reflectiveCalls
-
-object WirelessRedstoneCBE {
-  private def ether = try Option(Class.forName("codechicken.wirelessredstone.core.RedstoneEther").getMethod("server").invoke(null).asInstanceOf[ {
-    def addReceivingDevice(device: WirelessReceivingDevice)
-
-    def removeReceivingDevice(device: WirelessReceivingDevice)
-
-    def addTransmittingDevice(device: WirelessTransmittingDevice)
-
-    def removeTransmittingDevice(device: WirelessTransmittingDevice)
-
-    def isFreqOn(freq: Int): Boolean
-  }])
-  catch {
-    case _: Throwable => None
-  }
-
-  def addTransmitter(rs: RedstoneWireless) {
-    if (rs.wirelessOutput && rs.wirelessFrequency > 0) {
-      ether.foreach(_.addTransmittingDevice(rs))
-    }
-  }
-
-  def removeTransmitter(rs: RedstoneWireless) {
-    if (rs.wirelessFrequency > 0) {
-      ether.foreach(_.removeTransmittingDevice(rs))
-    }
-  }
-
-  def addReceiver(rs: RedstoneWireless) {
-    ether.foreach(ether => {
-      ether.addReceivingDevice(rs)
-      if (rs.wirelessFrequency > 0) {
-        rs.wirelessInput = ether.isFreqOn(rs.wirelessFrequency)
-      }
-    })
-  }
-
-  def removeReceiver(rs: RedstoneWireless) {
-    ether.foreach(_.removeReceivingDevice(rs))
-  }
-
-  def updateOutput(rs: RedstoneWireless) {
-    if (rs.wirelessOutput) {
-      addTransmitter(rs)
-    }
-    else {
-      removeTransmitter(rs)
-    }
-  }
-
-  def getInput(rs: RedstoneWireless) = rs.wirelessInput
-}

src/main/scala/li/cil/oc/integration/wrcbe/ModWRCBE.scala

@@ -0,0 +1,13 @@
+package li.cil.oc.integration.wrcbe
+
+import li.cil.oc.integration.ModProxy
+import li.cil.oc.integration.Mods
+import li.cil.oc.integration.util.WirelessRedstone
+
+object ModWRCBE extends ModProxy {
+  override def getMod = Mods.WirelessRedstoneCBE
+
+  override def initialize() {
+    WirelessRedstone.systems += WirelessRedstoneCBE
+  }
+}

src/main/scala/li/cil/oc/integration/wrcbe/WirelessRedstoneCBE.scala

@@ -0,0 +1,43 @@
+package li.cil.oc.integration.wrcbe
+
+import codechicken.wirelessredstone.core.RedstoneEther
+import li.cil.oc.integration.util.WirelessRedstone.WirelessRedstoneSystem
+import li.cil.oc.server.component.RedstoneWireless
+
+import scala.language.reflectiveCalls
+
+object WirelessRedstoneCBE extends WirelessRedstoneSystem {
+  def addTransmitter(rs: RedstoneWireless) {
+    if (rs.wirelessOutput && rs.wirelessFrequency > 0) {
+      RedstoneEther.server.addTransmittingDevice(rs)
+    }
+  }
+
+  def removeTransmitter(rs: RedstoneWireless) {
+    if (rs.wirelessFrequency > 0) {
+      RedstoneEther.server.removeTransmittingDevice(rs)
+    }
+  }
+
+  def addReceiver(rs: RedstoneWireless) {
+    RedstoneEther.server.addReceivingDevice(rs)
+    if (rs.wirelessFrequency > 0) {
+      rs.wirelessInput = RedstoneEther.server.isFreqOn(rs.wirelessFrequency)
+    }
+  }
+
+  def removeReceiver(rs: RedstoneWireless) {
+    RedstoneEther.server.removeReceivingDevice(rs)
+  }
+
+  def updateOutput(rs: RedstoneWireless) {
+    if (rs.wirelessOutput) {
+      addTransmitter(rs)
+    }
+    else {
+      removeTransmitter(rs)
+    }
+  }
+
+  def getInput(rs: RedstoneWireless) = rs.wirelessInput
+}

src/main/scala/li/cil/oc/integration/wrsve/ModWRSVE.scala

@@ -0,0 +1,13 @@
+package li.cil.oc.integration.wrsve
+
+import li.cil.oc.integration.ModProxy
+import li.cil.oc.integration.Mods
+import li.cil.oc.integration.util.WirelessRedstone
+
+object ModWRSVE extends ModProxy {
+  override def getMod = Mods.WirelessRedstoneSVE
+
+  override def initialize() {
+    WirelessRedstone.systems += WirelessRedstoneSVE
+  }
+}

src/main/scala/li/cil/oc/integration/wrsve/WirelessRedstoneSVE.scala

@@ -1,13 +1,14 @@
-package li.cil.oc.integration.util
+package li.cil.oc.integration.wrsve
 
+import li.cil.oc.integration.util.WirelessRedstone.WirelessRedstoneSystem
 import li.cil.oc.server.component.RedstoneWireless
 import net.minecraft.world.World
 
 import scala.language.reflectiveCalls
 
-object WirelessRedstoneSV {
+object WirelessRedstoneSVE extends WirelessRedstoneSystem {
   private val ether = try {
-    Option(Class.forName("wirelessredstone.ether.RedstoneEther").getMethod("getInstance").invoke(null).asInstanceOf[ {
+    Option(Class.forName("net.slimevoid.wirelessredstone.ether.RedstoneEther").getMethod("getInstance").invoke(null).asInstanceOf[ {
       def addTransmitter(world: World, x: Int, y: Int, z: Int, frequency: AnyRef)
 
       def remTransmitter(world: World, x: Int, y: Int, z: Int, frequency: AnyRef)

src/main/scala/li/cil/oc/server/component/RedstoneWireless.scala

@@ -104,6 +104,8 @@ trait RedstoneWireless extends Redstone[RedstoneAware] with WirelessReceivingDev
     if (node == this.node) {
       util.WirelessRedstone.removeReceiver(this)
       util.WirelessRedstone.removeTransmitter(this)
+      wirelessOutput = false
+      wirelessFrequency = 0
     }
   }