Error: Updated UE and Node class changes

src/main/scala/resonantinduction/archaic/firebox/TileFirebox.scala

@@ -1,7 +1,8 @@
 package resonantinduction.archaic.firebox
 
-import cpw.mods.fml.relauncher.Side
+import java.util.List
-import cpw.mods.fml.relauncher.SideOnly
+
+import cpw.mods.fml.relauncher.{Side, SideOnly}
 import io.netty.buffer.ByteBuf
 import net.minecraft.block.Block
 import net.minecraft.block.material.Material
@@ -10,8 +11,7 @@ import net.minecraft.creativetab.CreativeTabs
 import net.minecraft.entity.player.EntityPlayer
 import net.minecraft.init.Blocks
 import net.minecraft.inventory.IInventory
-import net.minecraft.item.Item
+import net.minecraft.item.{Item, ItemStack}
-import net.minecraft.item.ItemStack
 import net.minecraft.nbt.NBTTagCompound
 import net.minecraft.tileentity.TileEntityFurnace
 import net.minecraft.util.IIcon
@@ -19,25 +19,23 @@ import net.minecraftforge.common.MinecraftForge
 import net.minecraftforge.common.util.ForgeDirection
 import net.minecraftforge.fluids._
 import resonant.content.spatial.block.SpatialBlock
-import resonant.engine.grid.thermal.BoilEvent
+import resonant.engine.grid.thermal.{BoilEvent, ThermalPhysics}
-import resonant.engine.grid.thermal.ThermalPhysics
+import resonant.lib.content.prefab.TEnergyStorage
 import resonant.lib.content.prefab.java.TileElectricInventory
 import resonant.lib.network.Synced
-import resonant.lib.network.discriminator.PacketAnnotation
+import resonant.lib.network.discriminator.{PacketAnnotation, PacketType}
-import resonant.lib.network.discriminator.PacketType
 import resonant.lib.network.handle.IPacketReceiver
-import resonant.lib.utility.FluidUtility
-import resonantinduction.core.Reference
 import resonant.lib.transform.vector.Vector3
-import java.util.List
+import resonant.lib.utility.FluidUtility
 import resonant.lib.wrapper.WrapList._
+import resonantinduction.core.Reference
 
 /**
  * Meant to replace the furnace class.
  *
  * @author Calclavia
  */
-class TileFirebox extends TileElectricInventory(Material.rock) with IPacketReceiver with IFluidHandler
+class TileFirebox extends TileElectricInventory(Material.rock) with IPacketReceiver with IFluidHandler with TEnergyStorage
 {
   /**
    * 1KG of coal ~= 24MJ
@@ -53,8 +51,8 @@ class TileFirebox extends TileElectricInventory(Material.rock) with IPacketRecei
   private var boiledVolume: Int = 0
 
   //Constructor
-    setCapacity(POWER)
+  energy.setCapacity(POWER)
-    setMaxTransfer((POWER * 2) / 20)
+  energy.setMaxTransfer((POWER * 2) / 20)
   setIO(ForgeDirection.UP, 0)
 
   override def update
@@ -122,7 +120,8 @@ class TileFirebox extends TileElectricInventory(Material.rock) with IPacketRecei
           heatEnergy = 0
         }
         if (({
-                    burnTime -= 1; burnTime
+          burnTime -= 1;
+          burnTime
         }) == 0)
         {
           if (block eq Blocks.fire)

src/main/scala/resonantinduction/atomic/machine/accelerator/GuiAccelerator.scala

@@ -37,7 +37,7 @@ class GuiAccelerator(player: EntityPlayer, tileEntity: TileAccelerator) extends
         this.fontRendererObj.drawString("Antimatter: " + this.tileEntity.antimatter + " mg", 8, 80, 4210752)
         this.fontRendererObj.drawString("Status:", 8, 90, 4210752)
         this.fontRendererObj.drawString(status, 8, 100, 4210752)
-        this.fontRendererObj.drawString("Buffer: " + this.tileEntity.energy.getEnergy + "/" + new UnitDisplay(UnitDisplay.Unit.JOULES, this.tileEntity.energy.getEnergyCapacity, true), 8, 110, 4210752)
+       // this.fontRendererObj.drawString("Buffer: " + this.tileEntity.energy.getEnergy + "/" + new UnitDisplay(UnitDisplay.Unit.JOULES, this.tileEntity.energy.getEnergyCapacity, true), 8, 110, 4210752)
         this.fontRendererObj.drawString("Facing: " + this.tileEntity.getDirection.getOpposite, 100, 123, 4210752)
     }
 

src/main/scala/resonantinduction/atomic/machine/accelerator/TileAccelerator.scala

@@ -10,18 +10,19 @@ import net.minecraft.nbt.NBTTagCompound
 import net.minecraft.util.IIcon
 import net.minecraftforge.common.util.ForgeDirection
 import resonant.api.{IElectromagnet, IRotatable}
+import resonant.lib.content.prefab.TEnergyStorage
 import resonant.lib.content.prefab.java.TileElectricInventory
 import resonant.lib.network.discriminator.{PacketTile, PacketType}
 import resonant.lib.network.handle.TPacketIDReceiver
+import resonant.lib.transform.vector.Vector3
 import resonant.lib.utility.BlockUtility
 import resonantinduction.atomic.AtomicContent
 import resonantinduction.atomic.items.ItemAntimatter
 import resonantinduction.core.{Reference, ResonantInduction, Settings}
-import resonant.lib.transform.vector.Vector3
 
 import scala.collection.JavaConversions._
 
-class TileAccelerator extends TileElectricInventory(Material.iron) with IElectromagnet with IRotatable with TPacketIDReceiver
+class TileAccelerator extends TileElectricInventory(Material.iron) with IElectromagnet with IRotatable with TPacketIDReceiver with TEnergyStorage
 {
   final val DESC_PACKET_ID = 2;
   /**
@@ -43,8 +44,8 @@ class TileAccelerator extends TileElectricInventory(Material.iron) with IElectro
 
   //Constructor
   this.setSizeInventory(4)
-    this.setCapacity(Settings.ACCELERATOR_ENERGY_COST_PER_TICK * 20)
+  energy.setCapacity(Settings.ACCELERATOR_ENERGY_COST_PER_TICK * 20)
-    this.setMaxTransfer(Settings.ACCELERATOR_ENERGY_COST_PER_TICK)
+  energy.setMaxTransfer(Settings.ACCELERATOR_ENERGY_COST_PER_TICK)
 
   override def update
   {
@@ -310,7 +311,7 @@ class TileAccelerator extends TileElectricInventory(Material.iron) with IElectro
   @SideOnly(Side.CLIENT)
   override def getIcon(side: Int, meta: Int): IIcon =
   {
-        if(side == getDirection.getOpposite.ordinal())
+    if (side == getDirection.getOpposite.ordinal())
     {
       return AtomicContent.blockElectromagnet.getIcon(side, meta)
     }

src/main/scala/resonantinduction/atomic/machine/boiler/TileNuclearBoiler.scala

@@ -10,6 +10,7 @@ import net.minecraftforge.common.util.ForgeDirection
 import net.minecraftforge.fluids._
 import resonant.api.IRotatable
 import resonant.engine.ResonantEngine
+import resonant.lib.content.prefab.TEnergyStorage
 import resonant.lib.content.prefab.java.TileElectricInventory
 import resonant.lib.network.Synced
 import resonant.lib.network.discriminator.{PacketTile, PacketType}
@@ -26,7 +27,7 @@ object TileNuclearBoiler
     final val DIAN: Long = 50000
 }
 
-class TileNuclearBoiler extends TileElectricInventory(Material.iron) with IPacketReceiver with IFluidHandler with IRotatable
+class TileNuclearBoiler extends TileElectricInventory(Material.iron) with IPacketReceiver with IFluidHandler with IRotatable with TEnergyStorage
 {
     final val SHI_JIAN: Int = 20 * 15
 

src/main/scala/resonantinduction/atomic/machine/centrifuge/TileCentrifuge.scala

@@ -9,6 +9,7 @@ import net.minecraft.nbt.NBTTagCompound
 import net.minecraft.tileentity.TileEntity
 import net.minecraftforge.common.util.ForgeDirection
 import net.minecraftforge.fluids._
+import resonant.lib.content.prefab.TEnergyStorage
 import resonant.lib.content.prefab.java.TileElectricInventory
 import resonant.lib.grid.Compatibility
 import resonant.lib.network.discriminator.{PacketTile, PacketType}
@@ -26,7 +27,7 @@ object TileCentrifuge
     final val DIAN: Long = 500000
 }
 
-class TileCentrifuge extends TileElectricInventory(Material.iron) with IPacketReceiver with IFluidHandler with IInventory
+class TileCentrifuge extends TileElectricInventory(Material.iron) with IPacketReceiver with IFluidHandler with IInventory with TEnergyStorage
 {
     val gasTank: FluidTank = new FluidTank(FluidContainerRegistry.BUCKET_VOLUME * 5)
     var timer: Int = 0

src/main/scala/resonantinduction/atomic/machine/extractor/TileChemicalExtractor.scala

@@ -8,6 +8,7 @@ import net.minecraft.network.Packet
 import net.minecraftforge.common.util.ForgeDirection
 import net.minecraftforge.fluids._
 import resonant.engine.ResonantEngine
+import resonant.lib.content.prefab.TEnergyStorage
 import resonant.lib.grid.Compatibility
 import resonant.lib.network.Synced
 import resonant.lib.network.discriminator.PacketAnnotation
@@ -25,7 +26,7 @@ object TileChemicalExtractor
     final val ENERGY: Long = 5000
 }
 
-class TileChemicalExtractor extends TileProcess(Material.iron) with IFluidHandler
+class TileChemicalExtractor extends TileProcess(Material.iron) with IFluidHandler with TEnergyStorage
 {
     energy.setCapacity(TileChemicalExtractor.ENERGY * 2)
     this.setSizeInventory(7)

src/main/scala/resonantinduction/atomic/machine/fulmination/TileFulmination.scala

@@ -1,6 +1,7 @@
 package resonantinduction.atomic.machine.fulmination
 
 import net.minecraft.block.material.Material
+import resonant.lib.content.prefab.TEnergyStorage
 import resonant.lib.content.prefab.java.TileElectric
 
 /**
@@ -11,7 +12,7 @@ object TileFulmination
   private final val DIAN: Long = 10000000000000L
 }
 
-class TileFulmination extends TileElectric(Material.iron)
+class TileFulmination extends TileElectric(Material.iron) with TEnergyStorage
 {
   //Constructor
   energy.setCapacity(TileFulmination.DIAN * 2)

src/main/scala/resonantinduction/core/prefab/node/NodePressure.scala

@@ -2,39 +2,45 @@ package resonantinduction.core.prefab.node
 
 import net.minecraftforge.common.util.ForgeDirection
 import net.minecraftforge.fluids.{FluidStack, IFluidHandler}
-import resonant.api.grid.{IUpdate, INodeProvider}
+import resonant.api.grid.{INodeProvider, IUpdate}
 
-/**
+import scala.collection.convert.wrapAll._
- * Created by robert on 8/15/2014.
- */
-class NodePressure(parent : INodeProvider, buckets : Int) extends NodeTank(parent, buckets) with IUpdate {
 
-  def this(parent: INodeProvider)
+class NodePressure(parent: INodeProvider, buckets: Int = 1) extends NodeTank(parent, buckets) with IUpdate
+{
+  private var pressure: Int = 0
+
+  def update(deltaTime: Double)
   {
-    this(parent, 1)
+    if (!world.isRemote)
-  }
+    {
+      updatePressure()
 
-  def update(deltaTime: Double) {
+      if (getFluid != null)
-    if (!world.isRemote) {
+      {
-      updatePressure
+        for (entry <- directionMap.entrySet)
-      if (getFluid != null) {
+        {
-        import scala.collection.JavaConversions._
+          if (entry.getKey.isInstanceOf[INodeProvider] && (entry.getKey.asInstanceOf[INodeProvider]).getNode(classOf[NodePressure], entry.getValue.getOpposite).isInstanceOf[NodePressure])
-        for (entry <- connections.entrySet) {
+          {
-          if (entry.getKey.isInstanceOf[INodeProvider] && (entry.getKey.asInstanceOf[INodeProvider]).getNode(classOf[NodePressure], entry.getValue.getOpposite).isInstanceOf[NodePressure]) {
             val node: NodePressure = (entry.getKey.asInstanceOf[INodeProvider]).getNode(classOf[NodePressure], entry.getValue.getOpposite).asInstanceOf[NodePressure]
-            if (node.getPressure(entry.getValue.getOpposite) <= getPressure(entry.getValue)) {
+            if (node.getPressure(entry.getValue.getOpposite) <= getPressure(entry.getValue))
+            {
             }
           }
-          else if (entry.getKey.isInstanceOf[INodeProvider] && (entry.getKey.asInstanceOf[INodeProvider]).getNode(classOf[NodeTank], entry.getValue.getOpposite).isInstanceOf[NodeTank]) {
+          else if (entry.getKey.isInstanceOf[INodeProvider] && (entry.getKey.asInstanceOf[INodeProvider]).getNode(classOf[NodeTank], entry.getValue.getOpposite).isInstanceOf[NodeTank])
+          {
             val node: NodeTank = (entry.getKey.asInstanceOf[INodeProvider]).getNode(classOf[NodeTank], entry.getValue.getOpposite).asInstanceOf[NodeTank]
-            if (node.canFill(entry.getValue.getOpposite, getFluid.getFluid)) {
+            if (node.canFill(entry.getValue.getOpposite, getFluid.getFluid))
+            {
               val stack: FluidStack = drain(Integer.MAX_VALUE, false)
               val drained: Int = node.fill(stack, true)
               drain(drained, true)
             }
           }
-          else if (entry.getKey.isInstanceOf[IFluidHandler]) {
+          else if (entry.getKey.isInstanceOf[IFluidHandler])
-            if ((entry.getKey.asInstanceOf[IFluidHandler]).canFill(entry.getValue.getOpposite, getFluid.getFluid)) {
+          {
+            if ((entry.getKey.asInstanceOf[IFluidHandler]).canFill(entry.getValue.getOpposite, getFluid.getFluid))
+            {
               val stack: FluidStack = drain(Integer.MAX_VALUE, false)
               val drained: Int = (entry.getKey.asInstanceOf[IFluidHandler]).fill(entry.getValue.getOpposite, stack, true)
               drain(drained, true)
@@ -45,22 +51,16 @@ class NodePressure(parent : INodeProvider, buckets : Int) extends NodeTank(paren
     }
   }
 
-  def canUpdate: Boolean = {
+  protected def updatePressure()
-    return true
+  {
-  }
-
-  def continueUpdate: Boolean = {
-    return true
-  }
-
-  protected def updatePressure {
     var totalPressure: Int = 0
     val connectionSize: Int = connections.size
     var minPressure: Int = 0
     var maxPressure: Int = 0
-    import scala.collection.JavaConversions._
+    for (entry <- directionMap.entrySet)
-    for (entry <- connections.entrySet) {
+    {
-      if (entry.getKey.isInstanceOf[INodeProvider] && (entry.getKey.asInstanceOf[INodeProvider]).getNode(classOf[NodePressure], entry.getValue.getOpposite).isInstanceOf[NodePressure]) {
+      if (entry.getKey.isInstanceOf[INodeProvider] && (entry.getKey.asInstanceOf[INodeProvider]).getNode(classOf[NodePressure], entry.getValue.getOpposite).isInstanceOf[NodePressure])
+      {
         val node: NodePressure = (entry.getKey.asInstanceOf[INodeProvider]).getNode(classOf[NodePressure], entry.getValue.getOpposite).asInstanceOf[NodePressure]
         val pressure: Int = node.getPressure(entry.getValue.getOpposite)
         minPressure = Math.min(pressure, minPressure)
@@ -68,27 +68,35 @@ class NodePressure(parent : INodeProvider, buckets : Int) extends NodeTank(paren
         totalPressure += pressure
       }
     }
-    if (connectionSize == 0) {
+    if (connectionSize == 0)
+    {
       setPressure(0)
     }
-    else {
+    else
-      if (minPressure < 0) {
+    {
+      if (minPressure < 0)
+      {
         minPressure += 1
       }
-      if (maxPressure > 0) {
+      if (maxPressure > 0)
+      {
         maxPressure -= 1
       }
       setPressure(Math.max(minPressure, Math.min(maxPressure, totalPressure / connectionSize + Integer.signum(totalPressure))))
     }
   }
 
-  def getPressure(direction: ForgeDirection): Int = {
+  def getPressure(direction: ForgeDirection): Int =
+  {
     return pressure
   }
 
-  def setPressure(pressure: Int) {
+  def setPressure(pressure: Int)
+  {
     this.pressure = pressure
   }
 
-  private var pressure: Int = 0
+  def canUpdate =true
+
+  def continueUpdate = true
 }

src/main/scala/resonantinduction/core/prefab/node/NodeTank.scala

@@ -4,18 +4,17 @@ import net.minecraft.nbt.NBTTagCompound
 import net.minecraftforge.common.util.ForgeDirection
 import net.minecraftforge.fluids._
 import resonant.api.ISave
+import resonant.api.grid.{INode, INodeProvider}
 import resonant.lib.prefab.fluid.{LimitedTank, NodeFluidHandler}
 import resonant.lib.utility.WorldUtility
-import resonant.api.grid.{INodeProvider, INode}
 
 /**
  * Simple tank node designed to be implemented by any machine that can connect to other fluid based machines.
  *
  * @author Darkguardsman
  */
-class NodeTank(parent: INodeProvider, buckets: Int)  extends NodeFluidHandler(parent, new LimitedTank(buckets * FluidContainerRegistry.BUCKET_VOLUME)) with ISave with INode {
+class NodeTank(parent: INodeProvider, buckets: Int) extends NodeFluidHandler(parent, new LimitedTank(buckets * FluidContainerRegistry.BUCKET_VOLUME)) with ISave with INode
-
+{
-
   def load(nbt: NBTTagCompound)
   {
     getPrimaryTank.readFromNBT(nbt.getCompoundTag("tank"))
@@ -26,25 +25,30 @@ class NodeTank(parent: INodeProvider, buckets: Int)  extends NodeFluidHandler(pa
     nbt.setTag("tank", getPrimaryTank.writeToNBT(new NBTTagCompound))
   }
 
-  protected override def addConnection(obj: AnyRef, dir: ForgeDirection)
+  protected override def connect(obj: NodeFluidHandler, dir: ForgeDirection)
   {
-    super.addConnection(obj, dir)
+    super.connect(obj, dir)
+
     if (showConnectionsFor(obj, dir))
     {
       renderSides = WorldUtility.setEnableSide(getRenderSides, dir, true)
     }
   }
 
-  protected def showConnectionsFor(obj: AnyRef, dir: ForgeDirection): Boolean = {
+  protected def showConnectionsFor(obj: AnyRef, dir: ForgeDirection): Boolean =
-    if (obj != null) {
+  {
-      if (obj.getClass.isAssignableFrom(getParent.getClass)) {
+    if (obj != null)
+    {
+      if (obj.getClass.isAssignableFrom(getParent.getClass))
+      {
         return true
       }
     }
     return false
   }
 
-  def getRenderSides: Int = {
+  def getRenderSides: Int =
+  {
     return renderSides
   }
 

src/main/scala/resonantinduction/electrical/battery/GridBattery.scala

@@ -1,16 +1,17 @@
 package resonantinduction.electrical.battery
 
-import java.util.Arrays
+import java.util.{Arrays, LinkedHashSet, Set}
-import java.util.LinkedHashSet
+
-import java.util.Set
+import resonant.lib.content.prefab.TEnergyStorage
 import resonant.lib.grid.Grid
 import resonant.lib.grid.node.NodeEnergy
+
 import scala.collection.JavaConversions._
 
 /** Basic grid designed to be used for creating a level look for batteries connected together
   * @author robert(Darkguardsman)
   */
-class GridBattery extends Grid[TileBattery](classOf[NodeEnergy])
+class GridBattery extends Grid[TileBattery](classOf[NodeEnergy[_]]) with TEnergyStorage
 {
   var totalEnergy: Double = 0
   var totalCapacity: Double = 0
@@ -39,7 +40,7 @@ class GridBattery extends Grid[TileBattery](classOf[NodeEnergy])
     while (y >= 0 && y <= highestY && remainingRenderEnergy > 0)
     {
       val connectorsInlevel: Set[TileBattery] = new LinkedHashSet[TileBattery]
-            import scala.collection.JavaConversions._
+
       for (connector <- this.getNodes)
       {
         if (connector.yCoord == y)
@@ -49,7 +50,7 @@ class GridBattery extends Grid[TileBattery](classOf[NodeEnergy])
       }
       val levelSize: Int = connectorsInlevel.size
       var used: Double = 0
-            import scala.collection.JavaConversions._
+
       for (connector <- connectorsInlevel)
       {
         val tryInject: Double = Math.min(remainingRenderEnergy / levelSize, connector.energy.getEnergyCapacity)

src/main/scala/resonantinduction/electrical/wire/flat/PartFlatWire.scala

@@ -98,7 +98,7 @@ class PartFlatWire extends PartAbstract with TWire with TFacePart with TNormalOc
     if (!world.isRemote)
     {
       println(node)
-      println(node.getConnections.size())
+      println(node.connections.size())
     }
 
     return true
@@ -388,10 +388,12 @@ class PartFlatWire extends PartAbstract with TWire with TFacePart with TNormalOc
           if (tile.partMap(PartMap.edgeBetween(absDir, side)) == null)
           {
             val part = tile.partMap(absDir)
+            val to = ForgeDirection.getOrientation(absDir)
 
             if (canConnectTo(part))
             {
-              connections.put(part, ForgeDirection.getOrientation(absDir))
+              //TODO: Check dir
+              connect(part.asInstanceOf[INodeProvider].getNode(classOf[DCNode], to.getOpposite).asInstanceOf[DCNode], to)
               skip = true
             }
           }
@@ -438,13 +440,13 @@ class PartFlatWire extends PartAbstract with TWire with TFacePart with TNormalOc
 
               if (wire.canConnectTo(PartFlatWire.this, fromDir) && wire.maskOpen(otherR))
               {
-                connections.put(dcNode, forgeDir)
+                connect(dcNode, forgeDir)
                 return true
               }
             }
             else if (canConnectTo(part))
             {
-              connections.put(dcNode, forgeDir)
+              connect(dcNode, forgeDir)
               return true
             }
           }
@@ -462,7 +464,7 @@ class PartFlatWire extends PartAbstract with TWire with TFacePart with TNormalOc
 
       if (canConnectTo(tileEntity, forgeDir))
       {
-        connections.put(tileComponent, forgeDir)
+        connect(tileComponent, forgeDir)
         return true
       }
 
@@ -488,8 +490,8 @@ class PartFlatWire extends PartAbstract with TWire with TFacePart with TNormalOc
 
           if (canConnectTo(part, absForgeDir))
           {
-            //TODO: Connect to node, not part.
+            //TODO: Check dir
-            connections.put(part, absForgeDir)
+            connect(part.asInstanceOf[INodeProvider].getNode(classOf[DCNode], absForgeDir.getOpposite).asInstanceOf[DCNode], absForgeDir)
             return true
           }
         }
@@ -502,7 +504,7 @@ class PartFlatWire extends PartAbstract with TWire with TFacePart with TNormalOc
       if (!world.isRemote)
       {
         //TODO: Refine this. It's very hacky and may cause errors when the wire connects to a block both ways
-        val inverseCon = connections.map(_.swap)
+        val inverseCon = directionMap.map(_.swap)
         val forgeDir = ForgeDirection.getOrientation(i)
 
         if (inverseCon.contains(forgeDir))
@@ -511,7 +513,7 @@ class PartFlatWire extends PartAbstract with TWire with TFacePart with TNormalOc
 
           if (connected != null)
           {
-            connections -= connected
+            disconnect(connected)
           }
         }
       }

src/main/scala/resonantinduction/electrical/wire/framed/PartFramedWire.scala

@@ -35,7 +35,7 @@ class PartFramedWire extends PartFramedNode with TWire
 
     override protected def addConnection(obj: AnyRef, dir: ForgeDirection)
     {
-      super.addConnection(obj, dir)
+      super.connect(obj, dir)
       connectionMask = connectionMask.openMask(dir)
     }
   }

src/main/scala/resonantinduction/mechanical/mech/DebugFrameMechanical.java

@@ -90,9 +90,9 @@ public class DebugFrameMechanical extends FrameNodeDebug
             @Override
             public int getRowCount()
             {
-                if (getNode() != null && getNode().getConnections() != null)
+                if (getNode() != null && getNode().connections() != null)
                 {
-                    return getNode().getConnections().size();
+                    return getNode().connections().size();
                 }
                 return 10;
             }
@@ -100,10 +100,10 @@ public class DebugFrameMechanical extends FrameNodeDebug
             @Override
             public Object getValueAt(int row, int col)
             {
-                if (getNode() != null && getNode().getConnections() != null)
+                if (getNode() != null && getNode().connections() != null)
                 {
-                    ForgeDirection dir = (ForgeDirection) getNode().getConnections().values().toArray()[row];
+                    ForgeDirection dir = (ForgeDirection) getNode().connections().values().toArray()[row];
-                    MechanicalNode node = (MechanicalNode) getNode().getConnections().keySet().toArray()[row];
+                    MechanicalNode node = (MechanicalNode) getNode().connections().keySet().toArray()[row];
                     switch(col)
                     {
                         case 0: return dir;

src/main/scala/resonantinduction/mechanical/mech/MechanicalNode.java

@@ -20,7 +20,7 @@ import java.util.Map.Entry;
  * @author Calclavia, Darkguardsman
  */
 //Don't convert to scala as this will find its way into RE later - From Darkguardsman
-public class MechanicalNode extends NodeConnector implements TMultipartNode, IMechanicalNode, ISaveObj, IVectorWorld, IUpdate
+public class MechanicalNode extends NodeConnector<MechanicalNode> implements TMultipartNode, IMechanicalNode, ISaveObj, IVectorWorld, IUpdate
 {
 	/**
 	 * Marks that the rotation has changed and should be updated client side
@@ -164,7 +164,7 @@ public class MechanicalNode extends NodeConnector implements TMultipartNode, IMe
 			if (sharePower)
 			{
 				// Power sharing calculations
-				Iterator<Entry<Object, ForgeDirection>> it = getConnections().entrySet().iterator();
+				Iterator<Entry<Object, ForgeDirection>> it = connections().entrySet().iterator();
 
 				while (it.hasNext())
 				{
@@ -332,4 +332,10 @@ public class MechanicalNode extends NodeConnector implements TMultipartNode, IMe
 	{
 		return true;
 	}
+
+	@Override
+	public Class getConnectClass()
+	{
+		return getClass();
+	}
 }

src/main/scala/resonantinduction/mechanical/mech/gear/GearNode.scala

@@ -67,7 +67,7 @@ class GearNode(parent: PartGear) extends MechanicalNode(parent: PartGear)
             val instance: MechanicalNode = (tileBehind.asInstanceOf[INodeProvider]).getNode(classOf[MechanicalNode], gear.placementSide.getOpposite).asInstanceOf[MechanicalNode]
             if (instance != null && instance != this && !(instance.getParent.isInstanceOf[PartGearShaft]) && instance.canConnect(this,gear.placementSide.getOpposite))
             {
-                addConnection(instance, gear.placementSide)
+                connect(instance, gear.placementSide)
             }
         }
         for (i <- 0 until 6)
@@ -83,7 +83,7 @@ class GearNode(parent: PartGear) extends MechanicalNode(parent: PartGear)
                 val instance: MechanicalNode = (tile.asInstanceOf[INodeProvider]).getNode(classOf[MechanicalNode], if (checkDir eq gear.placementSide.getOpposite) ForgeDirection.UNKNOWN else checkDir).asInstanceOf[MechanicalNode]
                 if (!connections.containsValue(checkDir) && instance != this && checkDir != gear.placementSide && instance != null && instance.canConnect(this,checkDir.getOpposite))
                 {
-                    addConnection(instance, checkDir)
+                    connect(instance, checkDir)
                 }
             }
         }
@@ -101,7 +101,7 @@ class GearNode(parent: PartGear) extends MechanicalNode(parent: PartGear)
                 val instance: MechanicalNode = (checkTile.asInstanceOf[INodeProvider]).getNode(classOf[MechanicalNode], gear.placementSide).asInstanceOf[MechanicalNode]
                 if (instance != null && instance != this && instance.canConnect(this,checkDir.getOpposite) && !(instance.getParent.isInstanceOf[PartGearShaft]))
                 {
-                    addConnection(instance, checkDir)
+                    connect(instance, checkDir)
                 }
             }
         }

src/main/scala/resonantinduction/mechanical/mech/gearshaft/GearShaftNode.scala

@@ -9,7 +9,6 @@ import resonant.lib.transform.vector.Vector3
 
 class GearShaftNode(parent: INodeProvider) extends MechanicalNode(parent)
 {
-
   override def getTorqueLoad: Double =
   {
     shaft.tier match
@@ -40,9 +39,10 @@ class GearShaftNode(parent: INodeProvider) extends MechanicalNode(parent)
         if (shaft.tile.isInstanceOf[INodeProvider])
         {
           val instance: MechanicalNode = (shaft.tile.asInstanceOf[INodeProvider]).getNode(classOf[MechanicalNode], checkDir).asInstanceOf[MechanicalNode]
+
           if (instance != null && instance != this && instance.canConnect(this, checkDir.getOpposite))
           {
-            addConnection(instance, checkDir)
+            connect(instance, checkDir)
           }
         }
         else
@@ -53,7 +53,7 @@ class GearShaftNode(parent: INodeProvider) extends MechanicalNode(parent)
             val instance: MechanicalNode = (checkTile.asInstanceOf[INodeProvider]).getNode(classOf[MechanicalNode], checkDir.getOpposite).asInstanceOf[MechanicalNode]
             if (instance != null && instance != this && instance.getParent.isInstanceOf[PartGearShaft] && instance.canConnect(this, checkDir.getOpposite))
             {
-              addConnection(instance, checkDir)
+              connect(instance, checkDir)
             }
           }
         }