From a1c3a8e8e824741cf06859b6aed187bba0b6bf7a Mon Sep 17 00:00:00 2001
From: Calclavia <admin@calclavia.com>
Date: Sun, 18 Jan 2015 21:36:34 +0800
Subject: [PATCH] Started rework on reactor cell

---
 .../engineering/TileEngineeringTable.scala    | 316 +++++------
 .../smelting/firebox/TileFirebox.scala        |   6 +-
 src/main/scala/edx/core/ClientProxy.scala     |  57 +-
 src/main/scala/edx/core/CommonProxy.scala     |  10 +-
 .../mechanical/mech/grid/GridMechanical.scala |   9 +-
 .../scala/edx/quantum/QuantumContent.scala    | 138 ++---
 .../edx/quantum/items/ItemBreederFuel.scala   |   4 +-
 .../edx/quantum/items/ItemFissileFuel.scala   |  95 ----
 .../scala/edx/quantum/items/ItemFuelRod.scala |  88 ++++
 .../quantum/machine/plasma/TilePlasma.scala   |   6 +-
 .../machine/reactor/RenderReactorCell.scala   |  85 ---
 .../machine/reactor/TileReactorCell.scala     | 492 ------------------
 .../machine/reactor/TileReactorDrain.scala    | 193 -------
 .../reactor/ContainerReactorCell.scala        |   8 +-
 .../reactor/GuiReactorCell.scala              |   8 +-
 .../reactor/TileControlRod.scala              |   6 +-
 .../edx/quantum/reactor/TileReactorCell.scala | 455 ++++++++++++++++
 17 files changed, 817 insertions(+), 1159 deletions(-)
 delete mode 100644 src/main/scala/edx/quantum/items/ItemFissileFuel.scala
 create mode 100644 src/main/scala/edx/quantum/items/ItemFuelRod.scala
 delete mode 100644 src/main/scala/edx/quantum/machine/reactor/RenderReactorCell.scala
 delete mode 100644 src/main/scala/edx/quantum/machine/reactor/TileReactorCell.scala
 delete mode 100644 src/main/scala/edx/quantum/machine/reactor/TileReactorDrain.scala
 rename src/main/scala/edx/quantum/{machine => }/reactor/ContainerReactorCell.scala (87%)
 rename src/main/scala/edx/quantum/{machine => }/reactor/GuiReactorCell.scala (81%)
 rename src/main/scala/edx/quantum/{machine => }/reactor/TileControlRod.scala (67%)
 create mode 100644 src/main/scala/edx/quantum/reactor/TileReactorCell.scala

diff --git a/src/main/scala/edx/basic/engineering/TileEngineeringTable.scala b/src/main/scala/edx/basic/engineering/TileEngineeringTable.scala
index 6cf1b2f61..55ce7fefb 100644
--- a/src/main/scala/edx/basic/engineering/TileEngineeringTable.scala
+++ b/src/main/scala/edx/basic/engineering/TileEngineeringTable.scala
@@ -87,8 +87,8 @@ class TileEngineeringTable extends TileInventory(Material.wood) with IPacketRece
   private var playerSlots: Array[Int] = null
 
   //Constructor
-  bounds(new Cuboid(0, 0, 0, 1, 0.9f, 1))
-  isOpaqueCube(false)
+  bounds = new Cuboid(0, 0, 0, 1, 0.9f, 1)
+  isOpaqueCube = false
   itemBlock(classOf[ItemBlockSaved])
 
   @SideOnly(Side.CLIENT)
@@ -222,124 +222,6 @@ class TileEngineeringTable extends TileInventory(Material.wood) with IPacketRece
     return false
   }
 
-  override def setInventorySlotContents(slot: Int, itemStack: ItemStack)
-  {
-    if (slot < TileEngineeringTable.CRAFTING_MATRIX_END)
-    {
-      craftingMatrix(slot) = itemStack
-    }
-    else if (slot < TileEngineeringTable.CRAFTING_OUTPUT_END)
-    {
-      outputInventory(slot - TileEngineeringTable.CRAFTING_MATRIX_END) = itemStack
-    }
-    else if (slot < TileEngineeringTable.PLAYER_OUTPUT_END && this.invPlayer != null)
-    {
-      this.invPlayer.setInventorySlotContents(slot - TileEngineeringTable.CRAFTING_OUTPUT_END, itemStack)
-      val player: EntityPlayer = this.invPlayer.player
-      if (player.isInstanceOf[EntityPlayerMP])
-      {
-        (player.asInstanceOf[EntityPlayerMP]).sendContainerToPlayer(player.inventoryContainer)
-      }
-    }
-    else if (searchInventories)
-    {
-      var idDisplacement: Int = TileEngineeringTable.PLAYER_OUTPUT_END
-      for (dir <- ForgeDirection.VALID_DIRECTIONS)
-      {
-        val tile: TileEntity = toVectorWorld.add(dir).getTileEntity
-        if (tile.isInstanceOf[IInventory])
-        {
-          val inventory: IInventory = tile.asInstanceOf[IInventory]
-          val slotID: Int = slot - idDisplacement
-          if (slotID >= 0 && slotID < inventory.getSizeInventory)
-          {
-            inventory.setInventorySlotContents(slotID, itemStack)
-          }
-          idDisplacement += inventory.getSizeInventory
-        }
-      }
-    }
-    onInventoryChanged
-  }
-
-  /**
-   * Updates all the output slots. Call this to update the Engineering Table.
-   */
-  override def onInventoryChanged
-  {
-    if (worldObj != null)
-    {
-      if (!worldObj.isRemote)
-      {
-        this.outputInventory(TileEngineeringTable.CRAFTING_OUTPUT_SLOT) = null
-        var didCraft: Boolean = false
-        val inventoryCrafting: InventoryCrafting = this.getCraftingMatrix
-        val matrixOutput: ItemStack = CraftingManager.getInstance.findMatchingRecipe(inventoryCrafting, this.worldObj)
-        if (matrixOutput != null && this.getCraftingManager.getIdealRecipe(matrixOutput) != null)
-        {
-          this.outputInventory(TileEngineeringTable.CRAFTING_OUTPUT_SLOT) = matrixOutput
-          didCraft = true
-        }
-        if (!didCraft)
-        {
-          val filterStack: ItemStack = craftingMatrix(TileEngineeringTable.CENTER_SLOT)
-          if (filterStack != null && filterStack.getItem.isInstanceOf[ItemImprint])
-          {
-            val filters: java.util.List[ItemStack] = ItemImprint.getFilters(filterStack)
-            for (o <- filters)
-            {
-              val outputStack: ItemStack = o
-              if (outputStack != null)
-              {
-                val idealRecipe: Pair[ItemStack, Array[ItemStack]] = this.getCraftingManager.getIdealRecipe(outputStack)
-                if (idealRecipe != null)
-                {
-                  val recipeOutput: ItemStack = idealRecipe.left
-                  if (recipeOutput != null & recipeOutput.stackSize > 0)
-                  {
-                    this.outputInventory(TileEngineeringTable.CRAFTING_OUTPUT_SLOT) = recipeOutput
-                    didCraft = true
-                    worldObj.markBlockForUpdate(xCoord, yCoord, zCoord)
-                    return
-                  }
-                }
-              }
-            }
-          }
-        }
-        worldObj.markBlockForUpdate(xCoord, yCoord, zCoord)
-      }
-    }
-  }
-
-  /**
-   * Gets the AutoCraftingManager that does all the crafting results
-   */
-  def getCraftingManager: AutoCraftingManager =
-  {
-    if (craftManager == null)
-    {
-      craftManager = new AutoCraftingManager(this)
-    }
-    return craftManager
-  }
-
-  /**
-   * Construct an InventoryCrafting Matrix on the fly.
-   *
-   * @return
-   */
-  def getCraftingMatrix: InventoryCrafting =
-  {
-    val inventoryCrafting: InventoryCrafting = new InventoryCrafting(new ContainerDummy(this), 3, 3)
-
-    for (i <- 0 until this.craftingMatrix.length)
-    {
-      inventoryCrafting.setInventorySlotContents(i, this.craftingMatrix(i))
-    }
-    return inventoryCrafting
-  }
-
   /**
    * Creates a "fake inventory" and hook the player up to the crafter to use the player's items.
    */
@@ -536,6 +418,162 @@ class TileEngineeringTable extends TileInventory(Material.wood) with IPacketRece
     }
   }
 
+  override def setInventorySlotContents(slot: Int, itemStack: ItemStack)
+  {
+    if (slot < TileEngineeringTable.CRAFTING_MATRIX_END)
+    {
+      craftingMatrix(slot) = itemStack
+    }
+    else if (slot < TileEngineeringTable.CRAFTING_OUTPUT_END)
+    {
+      outputInventory(slot - TileEngineeringTable.CRAFTING_MATRIX_END) = itemStack
+    }
+    else if (slot < TileEngineeringTable.PLAYER_OUTPUT_END && this.invPlayer != null)
+    {
+      this.invPlayer.setInventorySlotContents(slot - TileEngineeringTable.CRAFTING_OUTPUT_END, itemStack)
+      val player: EntityPlayer = this.invPlayer.player
+      if (player.isInstanceOf[EntityPlayerMP])
+      {
+        (player.asInstanceOf[EntityPlayerMP]).sendContainerToPlayer(player.inventoryContainer)
+      }
+    }
+    else if (searchInventories)
+    {
+      var idDisplacement: Int = TileEngineeringTable.PLAYER_OUTPUT_END
+      for (dir <- ForgeDirection.VALID_DIRECTIONS)
+      {
+        val tile: TileEntity = toVectorWorld.add(dir).getTileEntity
+        if (tile.isInstanceOf[IInventory])
+        {
+          val inventory: IInventory = tile.asInstanceOf[IInventory]
+          val slotID: Int = slot - idDisplacement
+          if (slotID >= 0 && slotID < inventory.getSizeInventory)
+          {
+            inventory.setInventorySlotContents(slotID, itemStack)
+          }
+          idDisplacement += inventory.getSizeInventory
+        }
+      }
+    }
+    onInventoryChanged
+  }
+
+  /**
+   * Updates all the output slots. Call this to update the Engineering Table.
+   */
+  override def onInventoryChanged
+  {
+    if (worldObj != null)
+    {
+      if (!worldObj.isRemote)
+      {
+        this.outputInventory(TileEngineeringTable.CRAFTING_OUTPUT_SLOT) = null
+        var didCraft: Boolean = false
+        val inventoryCrafting: InventoryCrafting = this.getCraftingMatrix
+        val matrixOutput: ItemStack = CraftingManager.getInstance.findMatchingRecipe(inventoryCrafting, this.worldObj)
+        if (matrixOutput != null && this.getCraftingManager.getIdealRecipe(matrixOutput) != null)
+        {
+          this.outputInventory(TileEngineeringTable.CRAFTING_OUTPUT_SLOT) = matrixOutput
+          didCraft = true
+        }
+        if (!didCraft)
+        {
+          val filterStack: ItemStack = craftingMatrix(TileEngineeringTable.CENTER_SLOT)
+          if (filterStack != null && filterStack.getItem.isInstanceOf[ItemImprint])
+          {
+            val filters: java.util.List[ItemStack] = ItemImprint.getFilters(filterStack)
+            for (o <- filters)
+            {
+              val outputStack: ItemStack = o
+              if (outputStack != null)
+              {
+                val idealRecipe: Pair[ItemStack, Array[ItemStack]] = this.getCraftingManager.getIdealRecipe(outputStack)
+                if (idealRecipe != null)
+                {
+                  val recipeOutput: ItemStack = idealRecipe.left
+                  if (recipeOutput != null & recipeOutput.stackSize > 0)
+                  {
+                    this.outputInventory(TileEngineeringTable.CRAFTING_OUTPUT_SLOT) = recipeOutput
+                    didCraft = true
+                    worldObj.markBlockForUpdate(xCoord, yCoord, zCoord)
+                    return
+                  }
+                }
+              }
+            }
+          }
+        }
+        worldObj.markBlockForUpdate(xCoord, yCoord, zCoord)
+      }
+    }
+  }
+
+  /**
+   * Gets the AutoCraftingManager that does all the crafting results
+   */
+  def getCraftingManager: AutoCraftingManager =
+  {
+    if (craftManager == null)
+    {
+      craftManager = new AutoCraftingManager(this)
+    }
+    return craftManager
+  }
+
+  /**
+   * Construct an InventoryCrafting Matrix on the fly.
+   *
+   * @return
+   */
+  def getCraftingMatrix: InventoryCrafting =
+  {
+    val inventoryCrafting: InventoryCrafting = new InventoryCrafting(new ContainerDummy(this), 3, 3)
+
+    for (i <- 0 until this.craftingMatrix.length)
+    {
+      inventoryCrafting.setInventorySlotContents(i, this.craftingMatrix(i))
+    }
+    return inventoryCrafting
+  }
+
+  /**
+   * DO NOT USE THIS INTERNALLY. FOR EXTERNAL USE ONLY!
+   */
+  override def getStackInSlot(slot: Int): ItemStack =
+  {
+    if (slot < TileEngineeringTable.CRAFTING_MATRIX_END)
+    {
+      return this.craftingMatrix(slot)
+    }
+    else if (slot < TileEngineeringTable.CRAFTING_OUTPUT_END)
+    {
+      return outputInventory(slot - TileEngineeringTable.CRAFTING_MATRIX_END)
+    }
+    else if (slot < TileEngineeringTable.PLAYER_OUTPUT_END && invPlayer != null)
+    {
+      return this.invPlayer.getStackInSlot(slot - TileEngineeringTable.CRAFTING_OUTPUT_END)
+    }
+    else if (searchInventories)
+    {
+      var idDisplacement: Int = TileEngineeringTable.PLAYER_OUTPUT_END
+      for (dir <- ForgeDirection.VALID_DIRECTIONS)
+      {
+        val tile: TileEntity = toVectorWorld.add(dir).getTileEntity
+        if (tile.isInstanceOf[IInventory])
+        {
+          val inventory: IInventory = tile.asInstanceOf[IInventory]
+          val slotID: Int = slot - idDisplacement
+          if (slotID >= 0 && slotID < inventory.getSizeInventory)
+          {
+            return inventory.getStackInSlot(slotID)
+          }
+          idDisplacement += inventory.getSizeInventory
+        }
+      }
+    }
+    return null
+  }
+
   override def isItemValidForSlot(i: Int, itemstack: ItemStack): Boolean =
   {
     return true
@@ -637,44 +675,6 @@ class TileEngineeringTable extends TileInventory(Material.wood) with IPacketRece
     GL11.glPopMatrix
   }
 
-  /**
-   * DO NOT USE THIS INTERNALLY. FOR EXTERNAL USE ONLY!
-   */
-  override def getStackInSlot(slot: Int): ItemStack =
-  {
-    if (slot < TileEngineeringTable.CRAFTING_MATRIX_END)
-    {
-      return this.craftingMatrix(slot)
-    }
-    else if (slot < TileEngineeringTable.CRAFTING_OUTPUT_END)
-    {
-      return outputInventory(slot - TileEngineeringTable.CRAFTING_MATRIX_END)
-    }
-    else if (slot < TileEngineeringTable.PLAYER_OUTPUT_END && invPlayer != null)
-    {
-      return this.invPlayer.getStackInSlot(slot - TileEngineeringTable.CRAFTING_OUTPUT_END)
-    }
-    else if (searchInventories)
-    {
-      var idDisplacement: Int = TileEngineeringTable.PLAYER_OUTPUT_END
-      for (dir <- ForgeDirection.VALID_DIRECTIONS)
-      {
-        val tile: TileEntity = toVectorWorld.add(dir).getTileEntity
-        if (tile.isInstanceOf[IInventory])
-        {
-          val inventory: IInventory = tile.asInstanceOf[IInventory]
-          val slotID: Int = slot - idDisplacement
-          if (slotID >= 0 && slotID < inventory.getSizeInventory)
-          {
-            return inventory.getStackInSlot(slotID)
-          }
-          idDisplacement += inventory.getSizeInventory
-        }
-      }
-    }
-    return null
-  }
-
   override def getDirection: ForgeDirection =
   {
     return null
diff --git a/src/main/scala/edx/basic/process/smelting/firebox/TileFirebox.scala b/src/main/scala/edx/basic/process/smelting/firebox/TileFirebox.scala
index 596067b31..ff73c808e 100644
--- a/src/main/scala/edx/basic/process/smelting/firebox/TileFirebox.scala
+++ b/src/main/scala/edx/basic/process/smelting/firebox/TileFirebox.scala
@@ -184,13 +184,11 @@ class TileFirebox extends SpatialTile(Material.rock) with IFluidHandler with TIn
     }
   }
 
-  def isBurning: Boolean = burnTime > 0
-
   override def getSizeInventory = 1
 
   def getMeltIronEnergy(volume: Float): Long =
   {
-    val temperatureChange: Float = 1811 - ThermalPhysics.getTemperatureForCoordinate(worldObj, xCoord, zCoord)
+    val temperatureChange: Float = 1811 - ThermalPhysics.getDefaultTemperature(worldObj, xCoord, zCoord)
     val mass: Float = ThermalPhysics.getMass(volume, 7.9f)
     return (ThermalPhysics.getEnergyForTemperatureChange(mass, 450, temperatureChange) + ThermalPhysics.getEnergyForStateChange(mass, 272000)).asInstanceOf[Long]
   }
@@ -295,6 +293,8 @@ class TileFirebox extends SpatialTile(Material.rock) with IFluidHandler with TIn
     return if (isBurning) (if (isElectric) SpatialBlock.icon.get("firebox_electric_side_on") else SpatialBlock.icon.get("firebox_side_on")) else (if (isElectric) SpatialBlock.icon.get("firebox_electric_side_off") else SpatialBlock.icon.get("firebox_side_off"))
   }
 
+  def isBurning: Boolean = burnTime > 0
+
   override def click(player: EntityPlayer)
   {
     if (server)
diff --git a/src/main/scala/edx/core/ClientProxy.scala b/src/main/scala/edx/core/ClientProxy.scala
index 6f832bf1a..b5466b7c3 100644
--- a/src/main/scala/edx/core/ClientProxy.scala
+++ b/src/main/scala/edx/core/ClientProxy.scala
@@ -2,7 +2,7 @@ package edx.core
 
 import java.awt.Color
 
-import codechicken.multipart.{TMultiPart, TileMultipart}
+import codechicken.multipart.TileMultipart
 import cpw.mods.fml.client.FMLClientHandler
 import cpw.mods.fml.client.registry.{ClientRegistry, RenderingRegistry}
 import cpw.mods.fml.relauncher.{Side, SideOnly}
@@ -23,20 +23,19 @@ import edx.mechanical.mech.process.crusher.{RenderMechanicalPiston, TileMechanic
 import edx.mechanical.mech.turbine._
 import edx.quantum.gate.RenderQuantumGlyph
 import edx.quantum.laser.fx.{EntityBlockParticleFX, EntityLaserFX, EntityScorchFX}
-import edx.quantum.machine.accelerator.{EntityParticle, GuiAccelerator, RenderParticle, TileAccelerator}
+import edx.quantum.machine.accelerator.{EntityParticle, RenderParticle}
 import edx.quantum.machine.boiler.{GuiNuclearBoiler, RenderNuclearBoiler, TileNuclearBoiler}
 import edx.quantum.machine.centrifuge.{GuiCentrifuge, RenderCentrifuge, TileCentrifuge}
 import edx.quantum.machine.extractor.{GuiChemicalExtractor, RenderChemicalExtractor, TileChemicalExtractor}
 import edx.quantum.machine.plasma.{RenderPlasmaHeater, TilePlasmaHeater}
-import edx.quantum.machine.quantum.{GuiQuantumAssembler, RenderQuantumAssembler, TileQuantumAssembler}
-import edx.quantum.machine.reactor.{GuiReactorCell, RenderReactorCell, TileReactorCell}
+import edx.quantum.machine.quantum.{RenderQuantumAssembler, TileQuantumAssembler}
 import edx.quantum.machine.thermometer.{RenderThermometer, TileThermometer}
+import edx.quantum.reactor.{GuiReactorCell, TileReactorCell}
 import net.minecraft.block.Block
 import net.minecraft.client.gui.GuiScreen
 import net.minecraft.client.particle.{EntityDiggingFX, EntityFX}
 import net.minecraft.entity.player.EntityPlayer
 import net.minecraft.item.Item
-import net.minecraft.tileentity.TileEntity
 import net.minecraft.world.World
 import resonant.lib.render.fx.FXElectricBolt2
 import resonant.lib.render.wrapper.ItemRenderHandler
@@ -77,7 +76,6 @@ import resonant.lib.transform.vector.Vector3
     ClientRegistry.bindTileEntitySpecialRenderer(classOf[TileNuclearBoiler], new RenderNuclearBoiler)
     ClientRegistry.bindTileEntitySpecialRenderer(classOf[TileThermometer], new RenderThermometer)
     ClientRegistry.bindTileEntitySpecialRenderer(classOf[TileChemicalExtractor], new RenderChemicalExtractor)
-    ClientRegistry.bindTileEntitySpecialRenderer(classOf[TileReactorCell], new RenderReactorCell)
     ClientRegistry.bindTileEntitySpecialRenderer(classOf[TileQuantumAssembler], new RenderQuantumAssembler)
     RenderingRegistry.registerEntityRenderingHandler(classOf[EntityParticle], new RenderParticle)
 
@@ -88,40 +86,23 @@ import resonant.lib.transform.vector.Vector3
 
   override def getClientGuiElement(id: Int, player: EntityPlayer, world: World, x: Int, y: Int, z: Int): AnyRef =
   {
-    val tileEntity: TileEntity = world.getTileEntity(x, y, z)
-    if (tileEntity.isInstanceOf[TileMultipart])
+    world.getTileEntity(x, y, z) match
     {
-      val part: TMultiPart = (tileEntity.asInstanceOf[TileMultipart]).partMap(id)
-      if (part.isInstanceOf[PartMultimeter])
-      {
-        return new GuiMultimeter(player.inventory, part.asInstanceOf[PartMultimeter])
-      }
+      case tile: TileMultipart =>
+        val part = tile.partMap(id)
+        if (part.isInstanceOf[PartMultimeter])
+          new GuiMultimeter(player.inventory, part.asInstanceOf[PartMultimeter])
+        null
+      case tile: TileCentrifuge =>
+        new GuiCentrifuge(player.inventory, tile)
+      case tile: TileChemicalExtractor =>
+        new GuiChemicalExtractor(player.inventory, tile)
+      case tile: TileNuclearBoiler =>
+        new GuiNuclearBoiler(player, tile)
+      case tile: TileReactorCell =>
+        new GuiReactorCell(player.inventory, tile)
+      case _ => null
     }
-    else if (tileEntity.isInstanceOf[TileCentrifuge])
-    {
-      return new GuiCentrifuge(player.inventory, (tileEntity.asInstanceOf[TileCentrifuge]))
-    }
-    else if (tileEntity.isInstanceOf[TileChemicalExtractor])
-    {
-      return new GuiChemicalExtractor(player.inventory, (tileEntity.asInstanceOf[TileChemicalExtractor]))
-    }
-    else if (tileEntity.isInstanceOf[TileAccelerator])
-    {
-      return new GuiAccelerator(player, (tileEntity.asInstanceOf[TileAccelerator]))
-    }
-    else if (tileEntity.isInstanceOf[TileQuantumAssembler])
-    {
-      return new GuiQuantumAssembler(player.inventory, (tileEntity.asInstanceOf[TileQuantumAssembler]))
-    }
-    else if (tileEntity.isInstanceOf[TileNuclearBoiler])
-    {
-      return new GuiNuclearBoiler(player, (tileEntity.asInstanceOf[TileNuclearBoiler]))
-    }
-    else if (tileEntity.isInstanceOf[TileReactorCell])
-    {
-      return new GuiReactorCell(player.inventory, tileEntity.asInstanceOf[TileReactorCell])
-    }
-    return null
   }
 
   override def isPaused: Boolean =
diff --git a/src/main/scala/edx/core/CommonProxy.scala b/src/main/scala/edx/core/CommonProxy.scala
index 5d8f2a23e..2c2019ce0 100644
--- a/src/main/scala/edx/core/CommonProxy.scala
+++ b/src/main/scala/edx/core/CommonProxy.scala
@@ -9,7 +9,7 @@ import edx.quantum.machine.boiler.{ContainerNuclearBoiler, TileNuclearBoiler}
 import edx.quantum.machine.centrifuge.{ContainerCentrifuge, TileCentrifuge}
 import edx.quantum.machine.extractor.{ContainerChemicalExtractor, TileChemicalExtractor}
 import edx.quantum.machine.quantum.{ContainerQuantumAssembler, TileQuantumAssembler}
-import edx.quantum.machine.reactor.{ContainerReactorCell, TileReactorCell}
+import edx.quantum.reactor.{ContainerReactorCell, TileReactorCell}
 import net.minecraft.block.Block
 import net.minecraft.entity.player.EntityPlayer
 import net.minecraft.tileentity.TileEntity
@@ -101,15 +101,15 @@ class CommonProxy extends AbstractProxy
     this.renderElectricShock(world, start, target, r, g, b, true)
   }
 
+  def renderElectricShock(world: World, start: Vector3, target: Vector3, r: Float, g: Float, b: Float, split: Boolean)
+  {
+  }
+
   def renderElectricShock(world: World, start: Vector3, target: Vector3, color: Color, split: Boolean)
   {
     this.renderElectricShock(world, start, target, color.getRed / 255f, color.getGreen / 255f, color.getBlue / 255f, split)
   }
 
-  def renderElectricShock(world: World, start: Vector3, target: Vector3, r: Float, g: Float, b: Float, split: Boolean)
-  {
-  }
-
   def renderElectricShock(world: World, start: Vector3, target: Vector3)
   {
     this.renderElectricShock(world, start, target, true)
diff --git a/src/main/scala/edx/mechanical/mech/grid/GridMechanical.scala b/src/main/scala/edx/mechanical/mech/grid/GridMechanical.scala
index 593458788..9dcd9272c 100644
--- a/src/main/scala/edx/mechanical/mech/grid/GridMechanical.scala
+++ b/src/main/scala/edx/mechanical/mech/grid/GridMechanical.scala
@@ -34,23 +34,23 @@ class GridMechanical extends GridNode[NodeMechanical] with IUpdate
   override def reconstruct(first: NodeMechanical)
   {
     super.reconstruct(first)
-    UpdateTicker.threaded.addUpdater(this)
+    UpdateTicker.world.addUpdater(this)
     isLocked = false
   }
 
   override def deconstruct(first: NodeMechanical)
   {
     super.deconstruct(first)
-    UpdateTicker.threaded.removeUpdater(this)
+    UpdateTicker.world.removeUpdater(this)
   }
 
   override def update(deltaTime: Double)
   {
-    getNodes synchronized
+    nodes synchronized
     {
       load = 0
 
-      getNodes.foreach(
+      nodes.foreach(
         n =>
         {
           n.torque = 0
@@ -72,7 +72,6 @@ class GridMechanical extends GridNode[NodeMechanical] with IUpdate
 
       allPassed = Seq.empty[NodeMechanical]
 
-      //      UpdateTicker.world.enqueue(resetNodes)
       resetNodes()
     }
   }
diff --git a/src/main/scala/edx/quantum/QuantumContent.scala b/src/main/scala/edx/quantum/QuantumContent.scala
index b29307061..5da753ab5 100644
--- a/src/main/scala/edx/quantum/QuantumContent.scala
+++ b/src/main/scala/edx/quantum/QuantumContent.scala
@@ -16,7 +16,7 @@ import edx.quantum.machine.extractor.TileChemicalExtractor
 import edx.quantum.machine.fulmination.{FulminationHandler, TileFulmination}
 import edx.quantum.machine.plasma.{TilePlasma, TilePlasmaHeater}
 import edx.quantum.machine.quantum.TileQuantumAssembler
-import edx.quantum.machine.reactor.{TileControlRod, TileReactorCell}
+import edx.quantum.reactor.{TileControlRod, TileReactorCell}
 import edx.quantum.schematic.{SchematicAccelerator, SchematicBreedingReactor, SchematicFissionReactor, SchematicFusionReactor}
 import ic2.api.item.IC2Items
 import net.minecraft.block.Block
@@ -77,7 +77,7 @@ object QuantumContent extends ContentHolder
   //Cells
   @ExplicitContentName(value = "cellEmpty")
   var itemCell: Item = new ItemCell("cellEmpty")
-  var itemFissileFuel: Item = new ItemFissileFuel
+  var itemFissileFuel: Item = new ItemFuelRod
   var itemBreedingRod: Item = new ItemBreederFuel
   @ExplicitContentName
   var itemDarkMatter: Item = new ItemCell("darkMatter")
@@ -193,6 +193,63 @@ object QuantumContent extends ContentHolder
 
   def FLUID_PLASMA: Fluid = new Fluid("plasma").setGaseous(true)
 
+  def FLUID_URANIUM_HEXAFLOURIDE: Fluid =
+  {
+    var fluid: Fluid = FluidRegistry.getFluid("uraniumhexafluoride");
+    if (fluid == null)
+    {
+      fluid = new Fluid("uraniumhexafluoride").setGaseous(true)
+      FluidRegistry.registerFluid(fluid)
+    }
+    return fluid
+  }
+
+  def FLUID_STEAM: Fluid =
+  {
+    var fluid: Fluid = FluidRegistry.getFluid("steam");
+    if (fluid == null)
+    {
+      fluid = new Fluid("steam").setGaseous(true)
+      FluidRegistry.registerFluid(fluid)
+    }
+    return fluid
+  }
+
+  def FLUID_DEUTERIUM: Fluid =
+  {
+    var fluid: Fluid = FluidRegistry.getFluid("deuterium");
+    if (fluid == null)
+    {
+      fluid = new Fluid("deuterium").setGaseous(true)
+      FluidRegistry.registerFluid(fluid)
+    }
+    return fluid
+  }
+
+  /** Gets the Fluid instance of Tritium */
+  def getFluidTritium: Fluid =
+  {
+    var fluid: Fluid = FluidRegistry.getFluid("tritium");
+    if (fluid == null)
+    {
+      fluid = new Fluid("tritium").setGaseous(true)
+      FluidRegistry.registerFluid(fluid)
+    }
+    return fluid
+  }
+
+  /** Gets the Fluid instance of Toxic Waste */
+  def getFluidToxicWaste: Fluid =
+  {
+    var fluid: Fluid = FluidRegistry.getFluid("toxicwaste");
+    if (fluid == null)
+    {
+      fluid = new Fluid("toxicwaste").setGaseous(true)
+      FluidRegistry.registerFluid(fluid)
+    }
+    return fluid
+  }
+
   override def postInit()
   {
     super.postInit()
@@ -330,6 +387,16 @@ object QuantumContent extends ContentHolder
     return isItemStackOreDictionaryCompatible(itemStack, "cellWater")
   }
 
+  def isItemStackUraniumOre(itemStack: ItemStack): Boolean =
+  {
+    return isItemStackOreDictionaryCompatible(itemStack, "dropUranium", "oreUranium")
+  }
+
+  def isItemStackDeuteriumCell(itemStack: ItemStack): Boolean =
+  {
+    return isItemStackOreDictionaryCompatible(itemStack, "molecule_1d", "molecule_1h2", "cellDeuterium")
+  }
+
   /** Compare to Ore Dict
     *
     * @param itemStack
@@ -351,16 +418,6 @@ object QuantumContent extends ContentHolder
     return false
   }
 
-  def isItemStackUraniumOre(itemStack: ItemStack): Boolean =
-  {
-    return isItemStackOreDictionaryCompatible(itemStack, "dropUranium", "oreUranium")
-  }
-
-  def isItemStackDeuteriumCell(itemStack: ItemStack): Boolean =
-  {
-    return isItemStackOreDictionaryCompatible(itemStack, "molecule_1d", "molecule_1h2", "cellDeuterium")
-  }
-
   def isItemStackTritiumCell(itemStack: ItemStack): Boolean =
   {
     return isItemStackOreDictionaryCompatible(itemStack, "molecule_h3", "cellTritium")
@@ -379,69 +436,12 @@ object QuantumContent extends ContentHolder
 
   def FLUIDSTACK_URANIUM_HEXAFLOURIDE: FluidStack = new FluidStack(QuantumContent.FLUID_URANIUM_HEXAFLOURIDE, 0)
 
-  def FLUID_URANIUM_HEXAFLOURIDE: Fluid =
-  {
-    var fluid: Fluid = FluidRegistry.getFluid("uraniumhexafluoride");
-    if (fluid == null)
-    {
-      fluid = new Fluid("uraniumhexafluoride").setGaseous(true)
-      FluidRegistry.registerFluid(fluid)
-    }
-    return fluid
-  }
-
   def FLUIDSTACK_STEAM: FluidStack = new FluidStack(FLUID_STEAM, 0)
 
-  def FLUID_STEAM: Fluid =
-  {
-    var fluid: Fluid = FluidRegistry.getFluid("steam");
-    if (fluid == null)
-    {
-      fluid = new Fluid("steam").setGaseous(true)
-      FluidRegistry.registerFluid(fluid)
-    }
-    return fluid
-  }
-
   def FLUIDSTACK_DEUTERIUM: FluidStack = new FluidStack(FLUID_DEUTERIUM, 0)
 
-  def FLUID_DEUTERIUM: Fluid =
-  {
-    var fluid: Fluid = FluidRegistry.getFluid("deuterium");
-    if (fluid == null)
-    {
-      fluid = new Fluid("deuterium").setGaseous(true)
-      FluidRegistry.registerFluid(fluid)
-    }
-    return fluid
-  }
-
   def getFluidStackTritium: FluidStack = new FluidStack(getFluidTritium, 0)
 
-  /** Gets the Fluid instance of Tritium */
-  def getFluidTritium: Fluid =
-  {
-    var fluid: Fluid = FluidRegistry.getFluid("tritium");
-    if (fluid == null)
-    {
-      fluid = new Fluid("tritium").setGaseous(true)
-      FluidRegistry.registerFluid(fluid)
-    }
-    return fluid
-  }
-
   /** Gets a FluidStack of Toxic Waste */
   def getStackToxicWaste: FluidStack = new FluidStack(getFluidToxicWaste, 0)
-
-  /** Gets the Fluid instance of Toxic Waste */
-  def getFluidToxicWaste: Fluid =
-  {
-    var fluid: Fluid = FluidRegistry.getFluid("toxicwaste");
-    if (fluid == null)
-    {
-      fluid = new Fluid("toxicwaste").setGaseous(true)
-      FluidRegistry.registerFluid(fluid)
-    }
-    return fluid
-  }
 }
diff --git a/src/main/scala/edx/quantum/items/ItemBreederFuel.scala b/src/main/scala/edx/quantum/items/ItemBreederFuel.scala
index 0595a1912..9a8bfd2d7 100644
--- a/src/main/scala/edx/quantum/items/ItemBreederFuel.scala
+++ b/src/main/scala/edx/quantum/items/ItemBreederFuel.scala
@@ -9,13 +9,13 @@ import resonant.api.tile.{IReactor, IReactorComponent}
 class ItemBreederFuel extends ItemRadioactive with IReactorComponent
 {
   //Constructor
-  this.setMaxDamage(ItemFissileFuel.DECAY)
+  this.setMaxDamage(ItemFuelRod.decay)
   this.setMaxStackSize(1)
   this.setNoRepair
 
   override def onReact(itemStack: ItemStack, reactor: IReactor)
   {
-    reactor.heat(ItemFissileFuel.ENERGY_PER_TICK / 2)
+    reactor.heat(ItemFuelRod.energyPerTick / 2)
     if (reactor.world.getWorldTime % 20 == 0)
     {
       itemStack.setItemDamage(Math.min(itemStack.getItemDamage + 1, itemStack.getMaxDamage))
diff --git a/src/main/scala/edx/quantum/items/ItemFissileFuel.scala b/src/main/scala/edx/quantum/items/ItemFissileFuel.scala
deleted file mode 100644
index 16f3c0f71..000000000
--- a/src/main/scala/edx/quantum/items/ItemFissileFuel.scala
+++ /dev/null
@@ -1,95 +0,0 @@
-package edx.quantum.items
-
-import java.util.List
-
-import cpw.mods.fml.relauncher.{Side, SideOnly}
-import edx.core.{EDXCreativeTab, Reference, Settings}
-import edx.quantum.QuantumContent
-import edx.quantum.machine.reactor.TileReactorCell
-import net.minecraft.creativetab.CreativeTabs
-import net.minecraft.item.{Item, ItemStack}
-import net.minecraft.tileentity.TileEntity
-import net.minecraft.world.World
-import net.minecraftforge.common.util.ForgeDirection
-import net.minecraftforge.fluids.FluidStack
-import resonant.api.tile.{IReactor, IReactorComponent}
-import resonant.lib.transform.vector.Vector3
-import resonant.lib.wrapper.CollectionWrapper._
-
-/**
- * Fissile fuel rod
- */
-object ItemFissileFuel
-{
-  final val DECAY: Int = 2500
-  /**
-   * Temperature at which the fuel rod will begin to re-enrich itself.
-   */
-  final val BREEDING_TEMP: Int = 1100
-  /**
-   * The energy in one KG of uranium is: 72PJ, 100TJ in one cell of uranium.
-   */
-  final val ENERGY: Long = 100000000000L
-  /**
-   * Approximately 20,000,000J per tick. 400 MW.
-   */
-  final val ENERGY_PER_TICK: Long = ENERGY / 50000
-}
-
-class ItemFissileFuel extends ItemRadioactive with IReactorComponent
-{
-
-  //Constructor
-  this.setMaxStackSize(1)
-  this.setMaxDamage(ItemFissileFuel.DECAY)
-  this.setNoRepair
-  this.setUnlocalizedName(Reference.prefix + "rodBreederFuel")
-  this.setTextureName(Reference.prefix + "breederFuel")
-  setCreativeTab(EDXCreativeTab)
-
-  def onReact(itemStack: ItemStack, reactor: IReactor)
-  {
-    val tileEntity: TileEntity = reactor.asInstanceOf[TileEntity]
-    val worldObj: World = tileEntity.getWorldObj
-    var reactors: Int = 0
-
-    for (i <- 0 to 6)
-    {
-      val checkPos: Vector3 = new Vector3(tileEntity).add(ForgeDirection.getOrientation(i))
-      val tile: TileEntity = checkPos.getTileEntity(worldObj)
-      if (tile.isInstanceOf[TileReactorCell] && (tile.asInstanceOf[TileReactorCell]).getTemperature > ItemFissileFuel.BREEDING_TEMP)
-      {
-        reactors += 1
-      }
-    }
-
-    if (reactors >= 2)
-    {
-      if (worldObj.rand.nextInt(1000) <= 100 && reactor.getTemperature > (ItemFissileFuel.BREEDING_TEMP / 2))
-      {
-        val healAmt: Int = worldObj.rand.nextInt(5)
-        itemStack.setItemDamage(Math.max(itemStack.getItemDamage - healAmt, 0))
-      }
-    }
-    else
-    {
-      reactor.heat(ItemFissileFuel.ENERGY_PER_TICK)
-      if (reactor.world.getWorldTime % 20 == 0)
-      {
-        itemStack.setItemDamage(Math.min(itemStack.getItemDamage + 1, itemStack.getMaxDamage))
-      }
-      if (Settings.allowToxicWaste && worldObj.rand.nextFloat > 0.5)
-      {
-        val fluid: FluidStack = QuantumContent.getStackToxicWaste.copy
-        fluid.amount = 1
-        reactor.fill(ForgeDirection.UNKNOWN, fluid, true)
-      }
-    }
-  }
-
-  @SideOnly(Side.CLIENT) override def getSubItems(item: Item, par2CreativeTabs: CreativeTabs, par3List: List[_])
-  {
-    par3List.add(new ItemStack(item, 1, 0))
-    par3List.add(new ItemStack(item, 1, getMaxDamage - 1))
-  }
-}
\ No newline at end of file
diff --git a/src/main/scala/edx/quantum/items/ItemFuelRod.scala b/src/main/scala/edx/quantum/items/ItemFuelRod.scala
new file mode 100644
index 000000000..24047b329
--- /dev/null
+++ b/src/main/scala/edx/quantum/items/ItemFuelRod.scala
@@ -0,0 +1,88 @@
+package edx.quantum.items
+
+import java.util.List
+
+import cpw.mods.fml.relauncher.{Side, SideOnly}
+import edx.core.{EDXCreativeTab, Reference}
+import net.minecraft.creativetab.CreativeTabs
+import net.minecraft.item.{Item, ItemStack}
+import net.minecraft.tileentity.TileEntity
+import net.minecraftforge.common.util.ForgeDirection
+import resonant.api.tile.{IReactor, IReactorComponent}
+import resonant.lib.grid.thermal.ThermalGrid
+import resonant.lib.transform.vector.VectorWorld
+import resonant.lib.wrapper.CollectionWrapper._
+
+/**
+ * Fissile fuel rod
+ */
+object ItemFuelRod
+{
+  final val decay: Int = 2500
+  /**
+   * Temperature at which the fuel rod will begin to re-enrich itself.
+   */
+  final val breedingTemp: Int = 1100
+
+  /**
+   * The energy in one KG of uranium is: 72PJ, 100TJ in one cell of uranium.
+   */
+  final val energyDensity = 100000000000d
+  /**
+   * Approximately 20,000,000J per tick. 400 MW.
+   */
+  final val energyPerTick = energyDensity / 50000
+}
+
+class ItemFuelRod extends ItemRadioactive with IReactorComponent
+{
+  //Constructor
+  setMaxStackSize(1)
+  setMaxDamage(ItemFuelRod.decay)
+  setNoRepair()
+  setUnlocalizedName(Reference.prefix + "rodBreederFuel")
+  setTextureName(Reference.prefix + "breederFuel")
+  setCreativeTab(EDXCreativeTab)
+
+  def onReact(itemStack: ItemStack, reactor: IReactor)
+  {
+    val tile = reactor.asInstanceOf[TileEntity]
+    val world = tile.getWorldObj
+    val reactors =
+      ForgeDirection.VALID_DIRECTIONS
+        .map(d => (new VectorWorld(tile) + d).getTileEntity)
+        .filter(_.isInstanceOf[IReactor])
+        .count(t => ThermalGrid.getTemperature(new VectorWorld(t)) > ItemFuelRod.breedingTemp)
+
+    if (reactors >= 2)
+    {
+      /**
+       * Do fuel breeding
+       */
+      if (world.rand.nextInt(1000) <= 100 && ThermalGrid.getTemperature(new VectorWorld(tile)) > (ItemFuelRod.breedingTemp / 2))
+      {
+        val breedAmount = world.rand.nextInt(5)
+        itemStack.setItemDamage(Math.max(itemStack.getItemDamage - breedAmount, 0))
+      }
+    }
+    else
+    {
+      /**
+       * Do fission
+       */
+      reactor.heat(ItemFuelRod.energyPerTick)
+
+      if (reactor.world.getWorldTime % 20 == 0)
+      {
+        itemStack.setItemDamage(Math.min(itemStack.getItemDamage + 1, itemStack.getMaxDamage))
+      }
+    }
+  }
+
+  @SideOnly(Side.CLIENT)
+  override def getSubItems(item: Item, par2CreativeTabs: CreativeTabs, par3List: List[_])
+  {
+    par3List.add(new ItemStack(item, 1, 0))
+    par3List.add(new ItemStack(item, 1, getMaxDamage - 1))
+  }
+}
\ No newline at end of file
diff --git a/src/main/scala/edx/quantum/machine/plasma/TilePlasma.scala b/src/main/scala/edx/quantum/machine/plasma/TilePlasma.scala
index 8f027a64b..cd9781bab 100644
--- a/src/main/scala/edx/quantum/machine/plasma/TilePlasma.scala
+++ b/src/main/scala/edx/quantum/machine/plasma/TilePlasma.scala
@@ -27,8 +27,8 @@ class TilePlasma extends SpatialTile(Material.lava)
   private var temperature: Double = TilePlasma.plasmaMaxTemperature
 
   //Constructor
-  textureName_$eq("plasma")
-  isOpaqueCube(false)
+  textureName = "plasma"
+  isOpaqueCube = false
 
   override def getLightValue(access: IBlockAccess): Int =
   {
@@ -58,7 +58,7 @@ class TilePlasma extends SpatialTile(Material.lava)
   override def update
   {
     super.update
-    ThermalGrid.addTemperature(toVectorWorld, ((temperature - ThermalGrid.getTemperature(toVectorWorld)) * 0.1f).asInstanceOf[Float])
+    ThermalGrid.addHeat(toVectorWorld, ((temperature - ThermalGrid.getTemperature(toVectorWorld)) * 0.1f).asInstanceOf[Float])
     if (ticks % 20 == 0)
     {
       temperature /= 1.5
diff --git a/src/main/scala/edx/quantum/machine/reactor/RenderReactorCell.scala b/src/main/scala/edx/quantum/machine/reactor/RenderReactorCell.scala
deleted file mode 100644
index b789d2ac3..000000000
--- a/src/main/scala/edx/quantum/machine/reactor/RenderReactorCell.scala
+++ /dev/null
@@ -1,85 +0,0 @@
-package edx.quantum.machine.reactor
-
-import cpw.mods.fml.relauncher.{Side, SideOnly}
-import edx.core.Reference
-import net.minecraft.client.renderer.tileentity.TileEntitySpecialRenderer
-import net.minecraft.tileentity.TileEntity
-import net.minecraft.util.ResourceLocation
-import net.minecraftforge.client.model.{AdvancedModelLoader, IModelCustom}
-import org.lwjgl.opengl.GL11
-import resonant.lib.render.RenderUtility
-import resonant.lib.render.model.ModelCube
-
-@SideOnly(Side.CLIENT) object RenderReactorCell
-{
-  final val MODEL_TOP: IModelCustom = AdvancedModelLoader.loadModel(new ResourceLocation(Reference.domain, Reference.modelPath + "reactorCellTop.tcn"))
-  final val MODEL_MIDDLE: IModelCustom = AdvancedModelLoader.loadModel(new ResourceLocation(Reference.domain, Reference.modelPath + "reactorCellMiddle.tcn"))
-  final val MODEL_BOTTOM: IModelCustom = AdvancedModelLoader.loadModel(new ResourceLocation(Reference.domain, Reference.modelPath + "reactorCellBottom.tcn"))
-  final val TEXTURE_TOP: ResourceLocation = new ResourceLocation(Reference.domain, Reference.modelPath + "reactorCellTop.png")
-  final val TEXTURE_MIDDLE: ResourceLocation = new ResourceLocation(Reference.domain, Reference.modelPath + "reactorCellMiddle.png")
-  final val TEXTURE_BOTTOM: ResourceLocation = new ResourceLocation(Reference.domain, Reference.modelPath + "reactorCellBottom.png")
-  final val TEXTURE_FISSILE: ResourceLocation = new ResourceLocation(Reference.domain, Reference.modelPath + "fissileMaterial.png")
-}
-
-@SideOnly(Side.CLIENT) class RenderReactorCell extends TileEntitySpecialRenderer
-{
-  def renderTileEntityAt(t: TileEntity, x: Double, y: Double, z: Double, f: Float)
-  {
-    val tileEntity: TileReactorCell = t.asInstanceOf[TileReactorCell]
-    GL11.glPushMatrix
-    GL11.glTranslated(x + 0.5, y + 0.5, z + 0.5)
-    var meta: Int = 2
-    if (tileEntity.world != null)
-    {
-      meta = tileEntity.getBlockMetadata
-    }
-    val hasBelow: Boolean = tileEntity.world != null && t.getWorldObj.getTileEntity(t.xCoord, t.yCoord - 1, t.zCoord).isInstanceOf[TileReactorCell]
-
-    if (meta == 0)
-    {
-      bindTexture(RenderReactorCell.TEXTURE_BOTTOM)
-      RenderReactorCell.MODEL_BOTTOM.renderAll
-    }
-    else if (meta == 1)
-    {
-      bindTexture(RenderReactorCell.TEXTURE_MIDDLE)
-      GL11.glTranslatef(0, 0.075f, 0)
-      GL11.glScalef(1f, 1.15f, 1f)
-      RenderReactorCell.MODEL_MIDDLE.renderAll
-    }
-    else
-    {
-      bindTexture(RenderReactorCell.TEXTURE_TOP)
-      if (hasBelow)
-      {
-        GL11.glScalef(1f, 1.32f, 1f)
-      }
-      else
-      {
-        GL11.glTranslatef(0, 0.1f, 0)
-        GL11.glScalef(1f, 1.2f, 1f)
-      }
-      if (hasBelow)
-      {
-        RenderReactorCell.MODEL_TOP.renderAllExcept("BottomPad", "BaseDepth", "BaseWidth", "Base")
-      }
-      else
-      {
-        RenderReactorCell.MODEL_TOP.renderAll
-      }
-    }
-    GL11.glPopMatrix
-    if (tileEntity.getStackInSlot(0) != null)
-    {
-      val height: Float = tileEntity.getHeight * ((tileEntity.getStackInSlot(0).getMaxDamage - tileEntity.getStackInSlot(0).getItemDamage).asInstanceOf[Float] / tileEntity.getStackInSlot(0).getMaxDamage.asInstanceOf[Float])
-      GL11.glPushMatrix
-      GL11.glTranslatef(x.asInstanceOf[Float] + 0.5F, y.asInstanceOf[Float] + 0.5F * height, z.asInstanceOf[Float] + 0.5F)
-      GL11.glScalef(0.4f, 0.9f * height, 0.4f)
-      bindTexture(RenderReactorCell.TEXTURE_FISSILE)
-      RenderUtility.disableLighting
-      ModelCube.INSTNACE.render
-      RenderUtility.enableLighting
-      GL11.glPopMatrix
-    }
-  }
-}
\ No newline at end of file
diff --git a/src/main/scala/edx/quantum/machine/reactor/TileReactorCell.scala b/src/main/scala/edx/quantum/machine/reactor/TileReactorCell.scala
deleted file mode 100644
index 74fdade61..000000000
--- a/src/main/scala/edx/quantum/machine/reactor/TileReactorCell.scala
+++ /dev/null
@@ -1,492 +0,0 @@
-package edx.quantum.machine.reactor
-
-import java.util.{ArrayList, List}
-
-import cpw.mods.fml.relauncher.{Side, SideOnly}
-import edx.core.Reference
-import edx.quantum.QuantumContent
-import edx.quantum.machine.plasma.TilePlasma
-import net.minecraft.block.Block
-import net.minecraft.block.material.Material
-import net.minecraft.entity.EntityLiving
-import net.minecraft.entity.player.EntityPlayer
-import net.minecraft.init.Blocks
-import net.minecraft.item.ItemStack
-import net.minecraft.nbt.NBTTagCompound
-import net.minecraft.tileentity.TileEntity
-import net.minecraft.util.AxisAlignedBB
-import net.minecraft.world.World
-import net.minecraftforge.common.MinecraftForge
-import net.minecraftforge.common.util.ForgeDirection
-import net.minecraftforge.fluids.{Fluid, FluidContainerRegistry, FluidStack, FluidTank, FluidTankInfo, IFluidHandler}
-import resonant.api.event.PlasmaEvent
-import resonant.api.tile.{IReactor, IReactorComponent}
-import resonant.lib.grid.thermal.{ThermalGrid, ThermalPhysics}
-import resonant.lib.network.Synced
-import resonant.lib.network.Synced.{SyncedInput, SyncedOutput}
-import resonant.lib.network.discriminator.PacketAnnotation
-import resonant.lib.prefab.poison.PoisonRadiation
-import resonant.lib.prefab.tile.mixed.TileInventory
-import resonant.lib.prefab.tile.multiblock.reference.{IMultiBlockStructure, MultiBlockHandler}
-import resonant.lib.transform.vector.{Vector3, VectorWorld}
-import resonant.lib.utility.inventory.InventoryUtility
-
-import scala.collection.convert.wrapAll._
-
-/** The primary reactor component cell used to build reactors with.
-  *
-  * @author Calclavia */
-object TileReactorCell
-{
-  final val RADIUS: Int = 2
-  final val MELTING_POINT: Int = 2000
-}
-
-class TileReactorCell extends TileInventory(Material.iron) with IMultiBlockStructure[TileReactorCell] with IReactor with IFluidHandler
-{
-
-  private final val specificHeatCapacity: Int = 1000
-  private final val mass: Float = ThermalPhysics.getMass(1000, 7)
-  var tank: FluidTank = new FluidTank(FluidContainerRegistry.BUCKET_VOLUME * 15)
-  @Synced var temperature: Float = 295
-  private var previousTemperature: Float = 295
-  private var shouldUpdate: Boolean = false
-  private var prevInternalEnergy: Long = 0
-  private var internalEnergy: Long = 0
-  private var meltdownCounter: Int = 0
-  private var meltdownCounterMaximum: Int = 1000
-  /** Multiblock Methods. */
-  private var multiBlock: MultiBlockHandler[TileReactorCell] = null
-
-  textureName = "machine"
-  isOpaqueCube = false
-  normalRender = false
-
-  override def getSizeInventory: Int = 1
-
-  override def onWorldJoin
-  {
-    updatePositionStatus
-  }
-
-  override def onNeighborChanged(block: Block)
-  {
-    updatePositionStatus
-  }
-
-  /** Multiblock Methods */
-  def updatePositionStatus
-  {
-    val mainTile: TileReactorCell = getLowest
-    mainTile.getMultiBlock.deconstruct
-    mainTile.getMultiBlock.construct
-    val top: Boolean = (toVector3 + new Vector3(0, 1, 0)).getTileEntity(worldObj).isInstanceOf[TileReactorCell]
-    val bottom: Boolean = (toVector3 + new Vector3(0, -1, 0)).getTileEntity(worldObj).isInstanceOf[TileReactorCell]
-    if (top && bottom)
-    {
-      worldObj.setBlockMetadataWithNotify(xCoord, yCoord, zCoord, 1, 3)
-    }
-    else if (top)
-    {
-      worldObj.setBlockMetadataWithNotify(xCoord, yCoord, zCoord, 0, 3)
-    }
-    else
-    {
-      worldObj.setBlockMetadataWithNotify(xCoord, yCoord, zCoord, 2, 3)
-    }
-  }
-
-  def getLowest: TileReactorCell =
-  {
-    var lowest: TileReactorCell = this
-    val checkPosition: Vector3 = toVector3
-    while (true)
-    {
-      val t: TileEntity = checkPosition.getTileEntity(this.worldObj)
-      if (t.isInstanceOf[TileReactorCell])
-      {
-        lowest = t.asInstanceOf[TileReactorCell]
-      }
-      else
-      {
-        return lowest;
-      }
-      checkPosition.y -= 1
-    }
-    return lowest
-  }
-
-  override def getMultiBlock: MultiBlockHandler[TileReactorCell] =
-  {
-    if (multiBlock == null)
-    {
-      multiBlock = new MultiBlockHandler[TileReactorCell](this)
-    }
-    return multiBlock
-  }
-
-  override def update
-  {
-    super.update
-    if (!getMultiBlock.isPrimary)
-    {
-      if (getStackInSlot(0) != null)
-      {
-        if (getMultiBlock.get.getStackInSlot(0) == null)
-        {
-          getMultiBlock.get.setInventorySlotContents(0, getStackInSlot(0))
-          setInventorySlotContents(0, null)
-        }
-      }
-      if (tank.getFluidAmount > 0)
-      {
-        getMultiBlock.get.tank.fill(tank.drain(tank.getCapacity, true), true)
-      }
-    }
-    if (!getWorld.isRemote)
-    {
-      if (getMultiBlock().isPrimary() && tank.getFluid != null && tank.getFluid.fluidID == QuantumContent.FLUID_PLASMA.getID)
-      {
-        val drain: FluidStack = tank.drain(FluidContainerRegistry.BUCKET_VOLUME, false)
-        if (drain != null && drain.amount >= FluidContainerRegistry.BUCKET_VOLUME)
-        {
-          val spawnDir: ForgeDirection = ForgeDirection.getOrientation(worldObj.rand.nextInt(3) + 2)
-          val spawnPos: Vector3 = toVector3 + spawnDir + spawnDir
-          spawnPos.add(0, Math.max(worldObj.rand.nextInt(getHeight) - 1, 0), 0)
-          if (worldObj.isAirBlock(spawnPos.xi, spawnPos.yi, spawnPos.zi))
-          {
-            MinecraftForge.EVENT_BUS.post(new PlasmaEvent.SpawnPlasmaEvent(worldObj, spawnPos.xi, spawnPos.yi, spawnPos.zi, TilePlasma.plasmaMaxTemperature))
-            tank.drain(FluidContainerRegistry.BUCKET_VOLUME, true)
-          }
-        }
-      }
-      else
-      {
-        prevInternalEnergy = internalEnergy
-        val fuelRod: ItemStack = getMultiBlock.get.getStackInSlot(0)
-        if (fuelRod != null)
-        {
-          if (fuelRod.getItem.isInstanceOf[IReactorComponent])
-          {
-            (fuelRod.getItem.asInstanceOf[IReactorComponent]).onReact(fuelRod, this)
-            if (!worldObj.isRemote)
-            {
-              if (fuelRod.getItemDamage >= fuelRod.getMaxDamage)
-              {
-                getMultiBlock.get.setInventorySlotContents(0, null)
-              }
-            }
-            if (ticks % 20 == 0)
-            {
-              if (worldObj.rand.nextFloat > 0.65)
-              {
-                val entities: List[EntityLiving] = worldObj.getEntitiesWithinAABB(classOf[EntityLiving], AxisAlignedBB.getBoundingBox(xCoord - TileReactorCell.RADIUS * 2, yCoord - TileReactorCell.RADIUS * 2, zCoord - TileReactorCell.RADIUS * 2, xCoord + TileReactorCell.RADIUS * 2, yCoord + TileReactorCell.RADIUS * 2, zCoord + TileReactorCell.RADIUS * 2)).asInstanceOf[List[EntityLiving]]
-                for (entity <- entities)
-                {
-                  PoisonRadiation.INSTANCE.poisonEntity(toVector3, entity)
-                }
-              }
-            }
-          }
-        }
-        temperature = ThermalGrid.getTemperature(toVectorWorld)
-        if (internalEnergy - prevInternalEnergy > 0)
-        {
-          var deltaT: Float = ThermalPhysics.getTemperatureForEnergy(mass, specificHeatCapacity, ((internalEnergy - prevInternalEnergy) * 0.15).asInstanceOf[Long])
-          var rods: Int = 0
-
-          for (i <- 0 to 5)
-          {
-            {
-              val checkAdjacent: Vector3 = toVector3.add(ForgeDirection.getOrientation(i))
-              if (checkAdjacent.getBlock(worldObj) == QuantumContent.blockControlRod)
-              {
-                deltaT /= 1.1f
-                rods += 1
-              }
-            }
-          }
-          ThermalGrid.addTemperature(toVectorWorld, deltaT)
-          if (worldObj.rand.nextInt(80) == 0 && this.getTemperature >= 373)
-          {
-            worldObj.playSoundEffect(this.xCoord + 0.5F, this.yCoord + 0.5F, this.zCoord + 0.5F, "Fluid.lava", 0.5F, 2.1F + (worldObj.rand.nextFloat - worldObj.rand.nextFloat) * 0.85F)
-          }
-          if (worldObj.rand.nextInt(40) == 0 && this.getTemperature >= 373)
-          {
-            worldObj.playSoundEffect(this.xCoord + 0.5F, this.yCoord + 0.5F, this.zCoord + 0.5F, "Fluid.lavapop", 0.5F, 2.6F + (worldObj.rand.nextFloat - worldObj.rand.nextFloat) * 0.8F)
-          }
-          if (worldObj.getWorldTime % (QuantumContent.SECOND_IN_TICKS * 5.0F) == 0 && this.getTemperature >= 373)
-          {
-            val percentage: Float = Math.min(this.getTemperature / TileReactorCell.MELTING_POINT, 1.0F)
-            worldObj.playSoundEffect(this.xCoord + 0.5F, this.yCoord + 0.5F, this.zCoord + 0.5F, Reference.prefix + "reactorcell", percentage, 1.0F)
-          }
-          if (previousTemperature != temperature && !shouldUpdate)
-          {
-            shouldUpdate = true
-            previousTemperature = temperature
-          }
-          if (previousTemperature >= TileReactorCell.MELTING_POINT && meltdownCounter < meltdownCounterMaximum)
-          {
-            shouldUpdate = true
-            meltdownCounter += 1
-          }
-          else if (previousTemperature >= TileReactorCell.MELTING_POINT && meltdownCounter >= meltdownCounterMaximum)
-          {
-            meltdownCounter = 0
-            meltDown
-            return
-          }
-          if (previousTemperature < TileReactorCell.MELTING_POINT && meltdownCounter < meltdownCounterMaximum && meltdownCounter > 0)
-          {
-            meltdownCounter -= 1
-          }
-        }
-        internalEnergy = 0
-        if (isOverToxic)
-        {
-          val leakPos: VectorWorld = toVectorWorld.add(worldObj.rand.nextInt(20) - 10, worldObj.rand.nextInt(20) - 10, worldObj.rand.nextInt(20) - 10)
-          val block: Block = leakPos.getBlock
-          if (block == Blocks.grass)
-          {
-            leakPos.setBlock(world, QuantumContent.blockRadioactive)
-            tank.drain(FluidContainerRegistry.BUCKET_VOLUME, true)
-          }
-          else if (block == null)
-          {
-            if (tank.getFluid != null)
-            {
-              leakPos.setBlock(world, tank.getFluid.getFluid.getBlock)
-              tank.drain(FluidContainerRegistry.BUCKET_VOLUME, true)
-            }
-          }
-        }
-      }
-      if (ticks % 60 == 0 || shouldUpdate)
-      {
-        shouldUpdate = false
-        notifyChange
-        //sendPacket(getDescPacket)
-      }
-    }
-    else
-    {
-      if (worldObj.rand.nextInt(5) == 0 && this.getTemperature >= 373)
-      {
-        worldObj.spawnParticle("cloud", this.xCoord + worldObj.rand.nextInt(2), this.yCoord + 1.0F, this.zCoord + worldObj.rand.nextInt(2), 0, 0.1D, 0)
-        worldObj.spawnParticle("bubble", this.xCoord + worldObj.rand.nextInt(5), this.yCoord, this.zCoord + worldObj.rand.nextInt(5), 0, 0, 0)
-      }
-    }
-  }
-
-  def isOverToxic: Boolean =
-  {
-    return tank.getFluid != null && tank.getFluid.fluidID == QuantumContent.getFluidToxicWaste.getID && tank.getFluid.amount >= tank.getCapacity
-  }
-
-  def getWorld: World =
-  {
-    return worldObj
-  }
-
-  def getHeight: Int =
-  {
-    var height: Int = 0
-    val checkPosition: Vector3 = toVector3
-    var tile: TileEntity = this
-    while (tile.isInstanceOf[TileReactorCell])
-    {
-      checkPosition.y += 1
-      height += 1
-      tile = checkPosition.getTileEntity(worldObj)
-    }
-    return height
-  }
-
-  private def meltDown
-  {
-    if (!worldObj.isRemote)
-    {
-      this.worldObj.setBlock(this.xCoord, this.yCoord, this.zCoord, Blocks.lava)
-      //val reactorExplosion: ReactorExplosion = new ReactorExplosion(worldObj, null, xCoord, yCoord, zCoord, 9f)
-      //reactorExplosion.doExplosionA
-      //reactorExplosion.doExplosionB(true)
-    }
-  }
-
-  def getTemperature: Float =
-  {
-    return temperature
-  }
-
-  override def getDescPacket: PacketAnnotation =
-  {
-    return new PacketAnnotation(this)
-  }
-
-  def onMultiBlockChanged
-  {
-  }
-
-  override def getMultiBlockVectors: java.lang.Iterable[Vector3] =
-  {
-    val vectors: List[Vector3] = new ArrayList[Vector3]
-    val checkPosition: Vector3 = toVector3
-    while (true)
-    {
-      val t: TileEntity = checkPosition.getTileEntity(this.worldObj)
-      if (t.isInstanceOf[TileReactorCell])
-      {
-        vectors.add(checkPosition - getPosition)
-      }
-      else
-      {
-        return vectors
-      }
-      checkPosition.y += 1
-    }
-    return vectors
-  }
-
-  def getPosition: Vector3 =
-  {
-    return toVector3
-  }
-
-  /** Reads a tile entity from NBT. */
-  @SyncedInput override def readFromNBT(nbt: NBTTagCompound)
-  {
-    super.readFromNBT(nbt)
-    temperature = nbt.getFloat("temperature")
-    tank.readFromNBT(nbt)
-    getMultiBlock.load(nbt)
-  }
-
-  /** Writes a tile entity to NBT. */
-  @SyncedOutput override def writeToNBT(nbt: NBTTagCompound)
-  {
-    super.writeToNBT(nbt)
-    nbt.setFloat("temperature", temperature)
-    tank.writeToNBT(nbt)
-    getMultiBlock.save(nbt)
-  }
-
-  override def getInventoryStackLimit: Int =
-  {
-    return 1
-  }
-
-  /** Returns true if automation can insert the given item in the given slot from the given side.
-    * Args: Slot, item, side */
-  override def canInsertItem(slot: Int, items: ItemStack, side: Int): Boolean =
-  {
-    return this.isItemValidForSlot(slot, items)
-  }
-
-  override def isItemValidForSlot(slotID: Int, itemStack: ItemStack): Boolean =
-  {
-    if (getMultiBlock.isPrimary && getMultiBlock.get.getStackInSlot(0) == null)
-    {
-      return itemStack.getItem.isInstanceOf[IReactorComponent]
-    }
-    return false
-  }
-
-  override def isUseableByPlayer(par1EntityPlayer: EntityPlayer): Boolean =
-  {
-    return if (worldObj.getTileEntity(xCoord, yCoord, zCoord) ne this) false else par1EntityPlayer.getDistanceSq(xCoord + 0.5D, yCoord + 0.5D, zCoord + 0.5D) <= 64.0D
-  }
-
-  def getInvName: String =
-  {
-    return getBlockType.getLocalizedName
-  }
-
-  /** Fluid Functions. */
-  override def fill(from: ForgeDirection, resource: FluidStack, doFill: Boolean): Int =
-  {
-    return getMultiBlock.get.tank.fill(resource, doFill)
-  }
-
-  override def drain(from: ForgeDirection, maxDrain: Int, doDrain: Boolean): FluidStack =
-  {
-    return tank.drain(maxDrain, doDrain)
-  }
-
-  override def drain(from: ForgeDirection, resource: FluidStack, doDrain: Boolean): FluidStack =
-  {
-    if (resource == null || !resource.isFluidEqual(tank.getFluid))
-    {
-      return null
-    }
-    return tank.drain(resource.amount, doDrain)
-  }
-
-  override def canFill(from: ForgeDirection, fluid: Fluid): Boolean =
-  {
-    return fluid == QuantumContent.FLUID_PLASMA
-  }
-
-  override def canDrain(from: ForgeDirection, fluid: Fluid): Boolean =
-  {
-    return fluid == QuantumContent.getFluidToxicWaste
-  }
-
-  override def getTankInfo(from: ForgeDirection): Array[FluidTankInfo] =
-  {
-    return Array[FluidTankInfo](tank.getInfo)
-  }
-
-  @SideOnly(Side.CLIENT) override def getRenderBoundingBox: AxisAlignedBB =
-  {
-    if (getMultiBlock.isPrimary && getMultiBlock.isConstructed)
-    {
-      return AxisAlignedBB.getBoundingBox(x - 5, y - 5, z - 5, x + 5, y + 5, z + 5);
-    }
-    return super.getRenderBoundingBox
-  }
-
-  def heat(energy: Long)
-  {
-    internalEnergy = Math.max(internalEnergy + energy, 0)
-  }
-
-  /** Called when the block is right clicked by the player */
-  override protected def use(player: EntityPlayer, side: Int, hit: Vector3): Boolean =
-  {
-    if (!world.isRemote)
-    {
-      val tile: TileReactorCell = getMultiBlock.get()
-      if (player.inventory.getCurrentItem != null)
-      {
-        if (tile.getStackInSlot(0) == null)
-        {
-          if (player.inventory.getCurrentItem.getItem.isInstanceOf[IReactorComponent])
-          {
-            val itemStack: ItemStack = player.inventory.getCurrentItem.copy
-            itemStack.stackSize = 1
-            tile.setInventorySlotContents(0, itemStack)
-            player.inventory.decrStackSize(player.inventory.currentItem, 1)
-            return true
-          }
-        }
-      }
-      else if (player.isSneaking && tile.getStackInSlot(0) != null)
-      {
-        InventoryUtility.dropItemStack(world, new Vector3(player), tile.getStackInSlot(0), 0)
-        tile.setInventorySlotContents(0, null)
-        return true
-      }
-      else
-      {
-        player.openGui(QuantumContent, 0, world, tile.xCoord, tile.yCoord, tile.zCoord)
-      }
-    }
-    return true
-  }
-
-  override protected def markUpdate
-  {
-    super.markUpdate
-    shouldUpdate = true
-  }
-}
\ No newline at end of file
diff --git a/src/main/scala/edx/quantum/machine/reactor/TileReactorDrain.scala b/src/main/scala/edx/quantum/machine/reactor/TileReactorDrain.scala
deleted file mode 100644
index b186c4a61..000000000
--- a/src/main/scala/edx/quantum/machine/reactor/TileReactorDrain.scala
+++ /dev/null
@@ -1,193 +0,0 @@
-package edx.quantum.machine.reactor
-
-import java.util.{ArrayList, HashSet, List, Set}
-
-import cpw.mods.fml.relauncher.{Side, SideOnly}
-import net.minecraft.block.Block
-import net.minecraft.block.material.Material
-import net.minecraft.client.renderer.texture.IIconRegister
-import net.minecraft.entity.EntityLivingBase
-import net.minecraft.item.ItemStack
-import net.minecraft.tileentity.TileEntity
-import net.minecraft.util.{IIcon, MathHelper}
-import net.minecraft.world.World
-import net.minecraftforge.common.util.ForgeDirection
-import net.minecraftforge.fluids._
-import resonant.lib.prefab.tile.spatial.{SpatialBlock, SpatialTile}
-import resonant.lib.prefab.tile.traits.TRotatable
-import resonant.lib.transform.vector.Vector3
-import resonant.lib.utility.path.{IPathCallBack, Pathfinder}
-
-/**
- * Reactor Drain
- *
- * @author Calclavia
- */
-class TileReactorDrain extends SpatialTile(Material.iron) with IFluidHandler with TRotatable
-{
-  private final val tanks: Set[IFluidTank] = new HashSet[IFluidTank]
-  private var lastFindTime: Long = -1
-
-  override def canUpdate: Boolean =
-  {
-    return false
-  }
-
-  def fill(from: ForgeDirection, resource: FluidStack, doFill: Boolean): Int =
-  {
-    return 0
-  }
-
-  def drain(from: ForgeDirection, maxDrain: Int, doDrain: Boolean): FluidStack =
-  {
-    if (this.getOptimalTank != null)
-    {
-      return this.getOptimalTank.drain(maxDrain, doDrain)
-    }
-    return null
-  }
-
-  def drain(from: ForgeDirection, resource: FluidStack, doDrain: Boolean): FluidStack =
-  {
-    return null
-  }
-
-  def canFill(from: ForgeDirection, fluid: Fluid): Boolean =
-  {
-    return false
-  }
-
-  def canDrain(from: ForgeDirection, fluid: Fluid): Boolean =
-  {
-    return true
-  }
-
-  def getTankInfo(from: ForgeDirection): Array[FluidTankInfo] =
-  {
-    val tankInfoList: List[FluidTankInfo] = new ArrayList[FluidTankInfo]
-    this.getOptimalTank
-    import scala.collection.JavaConversions._
-    for (tank <- this.tanks)
-    {
-      tankInfoList.add(tank.getInfo)
-    }
-    return tankInfoList.toArray(new Array[FluidTankInfo](0))
-  }
-
-  def getOptimalTank: IFluidTank =
-  {
-    if (this.lastFindTime == -1 || this.worldObj.getWorldTime - this.lastFindTime > 20)
-    {
-      this.find
-    }
-    if (this.tanks.size > 0)
-    {
-      var optimalTank: IFluidTank = null
-      import scala.collection.JavaConversions._
-      for (tank <- this.tanks)
-      {
-        if (tank != null)
-        {
-          if (optimalTank == null || (optimalTank != null && getFluidSafe(tank.getFluid) > getFluidSafe(optimalTank.getFluid)))
-          {
-            optimalTank = tank
-          }
-        }
-      }
-      return optimalTank
-    }
-    return null
-  }
-
-  def find
-  {
-    this.tanks.clear
-    val world: World = this.worldObj
-    val position: Vector3 = toVector3
-    val finder: Pathfinder = new Pathfinder(new IPathCallBack
-    {
-      def getConnectedNodes(finder: Pathfinder, currentNode: Vector3): Set[Vector3] =
-      {
-        val neighbors: Set[Vector3] = new HashSet[Vector3]
-
-        for (i <- 0 to 6)
-        {
-          val direction: ForgeDirection = ForgeDirection.getOrientation(i)
-          val position: Vector3 = currentNode.clone.add(direction)
-          val block: Block = position.getBlock(world)
-          if (block == null || block.isInstanceOf[IFluidBlock] || position.getTileEntity(world).isInstanceOf[TileReactorCell])
-          {
-            neighbors.add(position)
-          }
-        }
-        return neighbors
-      }
-
-      def onSearch(finder: Pathfinder, start: Vector3, node: Vector3): Boolean =
-      {
-        if (node.getTileEntity(world).isInstanceOf[TileReactorCell])
-        {
-          finder.results.add(node)
-        }
-        if (node.distance(position) > 6)
-        {
-          return true
-        }
-        return false
-      }
-    }).init(toVector3.add(ForgeDirection.getOrientation(this.getBlockMetadata).getOpposite))
-    import scala.collection.JavaConversions._
-    for (node <- finder.results)
-    {
-      val tileEntity: TileEntity = node.getTileEntity(this.worldObj)
-      if (tileEntity.isInstanceOf[TileReactorCell])
-      {
-        this.tanks.add((tileEntity.asInstanceOf[TileReactorCell]).tank)
-      }
-    }
-    this.lastFindTime = this.worldObj.getWorldTime
-  }
-
-  def getFluidSafe(stack: FluidStack): Int =
-  {
-    if (stack != null)
-    {
-      return stack.amount
-    }
-    return 0
-  }
-
-  @SideOnly(Side.CLIENT) override def registerIcons(iconRegister: IIconRegister)
-  {
-    super.registerIcons(iconRegister)
-    SpatialBlock.icon.put("ReactorDrain_front", iconRegister.registerIcon("ReactorDrain_front"))
-  }
-
-  override def getIcon(side: Int, metadata: Int): IIcon =
-  {
-    if (side == metadata)
-    {
-      return SpatialBlock.icon.get("ReactorDrain_front")
-    }
-    return super.getIcon(side, metadata)
-  }
-
-  override def onPlaced(entityLiving: EntityLivingBase, itemStack: ItemStack)
-  {
-    if (MathHelper.abs(entityLiving.posX.asInstanceOf[Float] - xi) < 2.0F && MathHelper.abs(entityLiving.posZ.asInstanceOf[Float] - zi) < 2.0F)
-    {
-      val d0: Double = entityLiving.posY + 1.82D - entityLiving.yOffset
-      if (d0 - y > 2.0D)
-      {
-        world.setBlockMetadataWithNotify(xi, yi, zi, 1, 3)
-        return
-      }
-      if (y - d0 > 0.0D)
-      {
-        world.setBlockMetadataWithNotify(xi, yi, zi, 0, 3)
-        return
-      }
-    }
-    super.onPlaced(entityLiving, itemStack)
-  }
-}
\ No newline at end of file
diff --git a/src/main/scala/edx/quantum/machine/reactor/ContainerReactorCell.scala b/src/main/scala/edx/quantum/reactor/ContainerReactorCell.scala
similarity index 87%
rename from src/main/scala/edx/quantum/machine/reactor/ContainerReactorCell.scala
rename to src/main/scala/edx/quantum/reactor/ContainerReactorCell.scala
index 59fc77b8c..ff69ef35d 100644
--- a/src/main/scala/edx/quantum/machine/reactor/ContainerReactorCell.scala
+++ b/src/main/scala/edx/quantum/reactor/ContainerReactorCell.scala
@@ -1,6 +1,6 @@
-package edx.quantum.machine.reactor
+package edx.quantum.reactor
 
-import edx.quantum.items.{ItemBreederFuel, ItemFissileFuel}
+import edx.quantum.items.{ItemBreederFuel, ItemFuelRod}
 import net.minecraft.entity.player.EntityPlayer
 import net.minecraft.inventory.Slot
 import net.minecraft.item.ItemStack
@@ -10,8 +10,8 @@ import resonant.lib.prefab.gui.slot.SlotSpecific
 class ContainerReactorCell(player: EntityPlayer, tileEntity: TileReactorCell) extends ContainerBase(tileEntity)
 {
   //Constructor
-  this.addSlotToContainer(new SlotSpecific(tileEntity, 0, 79, 17, classOf[ItemFissileFuel], classOf[ItemBreederFuel]))
-  this.addPlayerInventory(player)
+  addSlotToContainer(new SlotSpecific(tileEntity, 0, 79, 17, classOf[ItemFuelRod], classOf[ItemBreederFuel]))
+  addPlayerInventory(player)
 
   /**
    * Called to transfer a stack from one inventory to the other eg. when shift clicking.
diff --git a/src/main/scala/edx/quantum/machine/reactor/GuiReactorCell.scala b/src/main/scala/edx/quantum/reactor/GuiReactorCell.scala
similarity index 81%
rename from src/main/scala/edx/quantum/machine/reactor/GuiReactorCell.scala
rename to src/main/scala/edx/quantum/reactor/GuiReactorCell.scala
index 17f46700a..8da792c99 100644
--- a/src/main/scala/edx/quantum/machine/reactor/GuiReactorCell.scala
+++ b/src/main/scala/edx/quantum/reactor/GuiReactorCell.scala
@@ -1,4 +1,4 @@
-package edx.quantum.machine.reactor
+package edx.quantum.reactor
 
 import net.minecraft.entity.player.InventoryPlayer
 import org.lwjgl.opengl.GL11
@@ -16,7 +16,7 @@ class GuiReactorCell(inventory: InventoryPlayer, tileEntity: TileReactorCell) ex
     if (tileEntity.getStackInSlot(0) != null)
     {
       fontRendererObj.drawString(LanguageUtility.getLocal("tooltip.temperature"), 9, 45, 4210752)
-      fontRendererObj.drawString(String.valueOf(tileEntity.getTemperature.asInstanceOf[Int]) + "/" + String.valueOf(TileReactorCell.MELTING_POINT) + " K", 9, 58, 4210752)
+      //      fontRendererObj.drawString(String.valueOf(tileEntity.getTemperature.asInstanceOf[Int]) + "/" + String.valueOf(TileReactorCell.meltingPoint) + " K", 9, 58, 4210752)
       val secondsLeft: Int = (tileEntity.getStackInSlot(0).getMaxDamage - tileEntity.getStackInSlot(0).getItemDamage)
       fontRendererObj.drawString(LanguageUtility.getLocal("tooltip.remainingTime"), 100, 45, 4210752)
       fontRendererObj.drawString(secondsLeft + " seconds", 100, 58, 4210752)
@@ -31,13 +31,13 @@ class GuiReactorCell(inventory: InventoryPlayer, tileEntity: TileReactorCell) ex
   {
     super.drawGuiContainerBackgroundLayer(par1, x, y)
     drawSlot(78, 16)
-    drawMeter(80, 36, tileEntity.tank.getFluidAmount.asInstanceOf[Float] / tileEntity.tank.getCapacity.asInstanceOf[Float], tileEntity.tank.getFluid)
+    //    drawMeter(80, 36, tileEntity.tank.getFluidAmount.asInstanceOf[Float] / tileEntity.tank.getCapacity.asInstanceOf[Float], tileEntity.tank.getFluid)
     if (tileEntity.getStackInSlot(0) != null)
     {
       GL11.glPushMatrix
       GL11.glTranslatef(32 * 2, 0, 0)
       GL11.glScalef(0.5f, 1, 1)
-      drawForce(20, 70, (tileEntity.getTemperature) / (TileReactorCell.MELTING_POINT))
+      //      drawForce(20, 70, (tileEntity.getTemperature) / (TileReactorCell.meltingPoint))
       GL11.glPopMatrix
       GL11.glPushMatrix
       GL11.glTranslatef(68 * 2, 0, 0)
diff --git a/src/main/scala/edx/quantum/machine/reactor/TileControlRod.scala b/src/main/scala/edx/quantum/reactor/TileControlRod.scala
similarity index 67%
rename from src/main/scala/edx/quantum/machine/reactor/TileControlRod.scala
rename to src/main/scala/edx/quantum/reactor/TileControlRod.scala
index 552b5607c..07d26815e 100644
--- a/src/main/scala/edx/quantum/machine/reactor/TileControlRod.scala
+++ b/src/main/scala/edx/quantum/reactor/TileControlRod.scala
@@ -1,4 +1,4 @@
-package edx.quantum.machine.reactor
+package edx.quantum.reactor
 
 import net.minecraft.block.material.Material
 import resonant.lib.prefab.tile.spatial.SpatialBlock
@@ -9,6 +9,6 @@ import resonant.lib.transform.region.Cuboid
  */
 class TileControlRod extends SpatialBlock(Material.iron)
 {
-  bounds(new Cuboid(0.3f, 0f, 0.3f, 0.7f, 1f, 0.7f))
-  isOpaqueCube(false)
+  bounds = new Cuboid(0.3f, 0f, 0.3f, 0.7f, 1f, 0.7f)
+  isOpaqueCube = true
 }
\ No newline at end of file
diff --git a/src/main/scala/edx/quantum/reactor/TileReactorCell.scala b/src/main/scala/edx/quantum/reactor/TileReactorCell.scala
new file mode 100644
index 000000000..e20f72645
--- /dev/null
+++ b/src/main/scala/edx/quantum/reactor/TileReactorCell.scala
@@ -0,0 +1,455 @@
+package edx.quantum.reactor
+
+import java.util
+import java.util.List
+
+import cpw.mods.fml.relauncher.{Side, SideOnly}
+import edx.core.{Electrodynamics, Reference}
+import edx.quantum.QuantumContent
+import net.minecraft.block.Block
+import net.minecraft.block.material.Material
+import net.minecraft.entity.EntityLiving
+import net.minecraft.entity.player.EntityPlayer
+import net.minecraft.init.Blocks
+import net.minecraft.item.ItemStack
+import net.minecraft.nbt.NBTTagCompound
+import net.minecraft.tileentity.TileEntity
+import net.minecraft.util.{AxisAlignedBB, ResourceLocation}
+import net.minecraft.world.World
+import net.minecraftforge.client.model.AdvancedModelLoader
+import net.minecraftforge.common.util.ForgeDirection
+import org.lwjgl.opengl.GL11
+import resonant.api.tile.{IReactor, IReactorComponent}
+import resonant.lib.grid.thermal.{ThermalGrid, ThermalPhysics}
+import resonant.lib.network.handle.{TPacketReceiver, TPacketSender}
+import resonant.lib.prefab.poison.PoisonRadiation
+import resonant.lib.prefab.tile.mixed.TileInventory
+import resonant.lib.prefab.tile.multiblock.reference.{IMultiBlockStructure, MultiBlockHandler}
+import resonant.lib.render.RenderUtility
+import resonant.lib.render.model.ModelCube
+import resonant.lib.transform.vector.Vector3
+import resonant.lib.utility.inventory.InventoryUtility
+
+import scala.collection.convert.wrapAll._
+
+/** The primary reactor component cell used to build reactors with.
+  *
+  * @author Calclavia */
+object TileReactorCell
+{
+  final val radius = 2
+  final val meltingPoint = 3000
+  final val specificHeatCapacity = 1000
+  final val mass = ThermalPhysics.getMass(1000, 7)
+
+  final val modelTop = AdvancedModelLoader.loadModel(new ResourceLocation(Reference.domain, Reference.modelPath + "reactorCellTop.tcn"))
+  final val modelMiddle = AdvancedModelLoader.loadModel(new ResourceLocation(Reference.domain, Reference.modelPath + "reactorCellMiddle.tcn"))
+  final val modelBottom = AdvancedModelLoader.loadModel(new ResourceLocation(Reference.domain, Reference.modelPath + "reactorCellBottom.tcn"))
+  final val textureTop = new ResourceLocation(Reference.domain, Reference.modelPath + "reactorCellTop.png")
+  final val textureMiddle = new ResourceLocation(Reference.domain, Reference.modelPath + "reactorCellMiddle.png")
+  final val textureBottom = new ResourceLocation(Reference.domain, Reference.modelPath + "reactorCellBottom.png")
+  final val textureFuel = new ResourceLocation(Reference.domain, Reference.modelPath + "fissileMaterial.png")
+}
+
+class TileReactorCell extends TileInventory(Material.iron) with IMultiBlockStructure[TileReactorCell] with IReactor with TPacketSender with TPacketReceiver
+{
+  /** Multiblock Methods. */
+  private val multiBlock = new MultiBlockHandler[TileReactorCell](this)
+  private var internalEnergy = 0d
+
+  textureName = "machine"
+  isOpaqueCube = false
+  normalRender = false
+
+  override def getSizeInventory = 1
+
+  override def onWorldJoin()
+  {
+    updatePositionStatus()
+  }
+
+  override def onNeighborChanged(block: Block)
+  {
+    updatePositionStatus()
+  }
+
+  /** Multiblock Methods */
+  def updatePositionStatus()
+  {
+    val mainTile = getLowest
+    mainTile.getMultiBlock.deconstruct()
+    mainTile.getMultiBlock.construct()
+
+    val top = (toVector3 + new Vector3(0, 1, 0)).getTileEntity(worldObj).isInstanceOf[TileReactorCell]
+    val bottom = (toVector3 + new Vector3(0, -1, 0)).getTileEntity(worldObj).isInstanceOf[TileReactorCell]
+
+    if (top && bottom)
+    {
+      setMeta(1)
+    }
+    else if (top)
+    {
+      setMeta(0)
+    }
+    else
+    {
+      setMeta(2)
+    }
+  }
+
+  /**
+   * @return Gets the lowest reactor cell in this "tower"
+   */
+  def getLowest: TileReactorCell =
+  {
+    var lowest: TileReactorCell = this
+    val checkPosition: Vector3 = toVector3
+    while (true)
+    {
+      val t: TileEntity = checkPosition.getTileEntity(this.worldObj)
+      if (t.isInstanceOf[TileReactorCell])
+      {
+        lowest = t.asInstanceOf[TileReactorCell]
+      }
+      else
+      {
+        return lowest
+      }
+      checkPosition.y -= 1
+    }
+    return lowest
+  }
+
+  override def update()
+  {
+    super.update()
+
+    /**
+     * Move the fuel rod down into the main reactor.
+     */
+    if (!getMultiBlock.isPrimary)
+    {
+      if (getStackInSlot(0) != null)
+      {
+        if (getMultiBlock.get.getStackInSlot(0) == null)
+        {
+          getMultiBlock.get.setInventorySlotContents(0, getStackInSlot(0))
+          setInventorySlotContents(0, null)
+        }
+      }
+    }
+
+    if (!getWorld.isRemote)
+    {
+      /*
+      if (getMultiBlock().isPrimary() && tank.getFluid != null && tank.getFluid.fluidID == QuantumContent.FLUID_PLASMA.getID)
+      {
+        val drain: FluidStack = tank.drain(FluidContainerRegistry.BUCKET_VOLUME, false)
+        if (drain != null && drain.amount >= FluidContainerRegistry.BUCKET_VOLUME)
+        {
+          val spawnDir: ForgeDirection = ForgeDirection.getOrientation(worldObj.rand.nextInt(3) + 2)
+          val spawnPos: Vector3 = toVector3 + spawnDir + spawnDir
+          spawnPos.add(0, Math.max(worldObj.rand.nextInt(getHeight) - 1, 0), 0)
+          if (worldObj.isAirBlock(spawnPos.xi, spawnPos.yi, spawnPos.zi))
+          {
+            MinecraftForge.EVENT_BUS.post(new PlasmaEvent.SpawnPlasmaEvent(worldObj, spawnPos.xi, spawnPos.yi, spawnPos.zi, TilePlasma.plasmaMaxTemperature))
+            tank.drain(FluidContainerRegistry.BUCKET_VOLUME, true)
+          }
+        }
+      }
+      else
+      {*/
+
+      /**
+       * Fission reaction
+       */
+      val fuelRod = getMultiBlock.get.getStackInSlot(0)
+
+      if (fuelRod != null)
+      {
+        if (fuelRod.getItem.isInstanceOf[IReactorComponent])
+        {
+          fuelRod.getItem.asInstanceOf[IReactorComponent].onReact(fuelRod, this)
+
+          if (!worldObj.isRemote)
+          {
+            if (fuelRod.getItemDamage >= fuelRod.getMaxDamage)
+            {
+              getMultiBlock.get.setInventorySlotContents(0, null)
+            }
+          }
+
+          /**
+           * Radiation
+           */
+          //TODO: Raycast radiation code
+          if (ticks % 20 == 0)
+          {
+            if (worldObj.rand.nextFloat > 0.65)
+            {
+              val entities = worldObj.getEntitiesWithinAABB(classOf[EntityLiving], AxisAlignedBB.getBoundingBox(xCoord - TileReactorCell.radius * 2, yCoord - TileReactorCell.radius * 2, zCoord - TileReactorCell.radius * 2, xCoord + TileReactorCell.radius * 2, yCoord + TileReactorCell.radius * 2, zCoord + TileReactorCell.radius * 2)).asInstanceOf[List[EntityLiving]]
+              for (entity <- entities)
+              {
+                PoisonRadiation.INSTANCE.poisonEntity(toVector3, entity)
+              }
+            }
+          }
+        }
+      }
+
+      /**
+       * Heats up the surroundings. Control rods absorbs neutrons, reducing the heat produced.
+       */
+      val controlRodCount = ForgeDirection.VALID_DIRECTIONS.map(toVectorWorld + _).count(_.getBlock == QuantumContent.blockControlRod)
+      ThermalGrid.addHeat(toVectorWorld, internalEnergy / ((controlRodCount + 1) * 0.3))
+
+      val temperature = ThermalGrid.getTemperature(toVectorWorld)
+
+      /**
+       * Play sound effects
+       */
+      if (temperature >= 373)
+      {
+        if (world.rand.nextInt(80) == 0)
+        {
+          world.playSoundEffect(xCoord + 0.5F, yCoord + 0.5F, zCoord + 0.5F, "Fluid.lava", 0.5F, 2.1F + (worldObj.rand.nextFloat - worldObj.rand.nextFloat) * 0.85F)
+        }
+        if (world.rand.nextInt(40) == 0)
+        {
+          world.playSoundEffect(xCoord + 0.5F, yCoord + 0.5F, zCoord + 0.5F, "Fluid.lavapop", 0.5F, 2.6F + (worldObj.rand.nextFloat - worldObj.rand.nextFloat) * 0.8F)
+        }
+
+        if (ticks % (20 * 5) == 0)
+        {
+          world.playSoundEffect(this.xCoord + 0.5F, this.yCoord + 0.5F, this.zCoord + 0.5F, Reference.prefix + "reactorcell", temperature / TileReactorCell.meltingPoint, 1.0F)
+        }
+      }
+
+      if (temperature > TileReactorCell.meltingPoint)
+      {
+        meltDown()
+      }
+      internalEnergy = 0
+    }
+    else
+    {
+      val temperature = ThermalGrid.getTemperature(toVectorWorld)
+
+      if (world.rand.nextInt(5) == 0 && temperature >= 373)
+      {
+        world.spawnParticle("cloud", this.xCoord + worldObj.rand.nextInt(2), this.yCoord + 1.0F, this.zCoord + worldObj.rand.nextInt(2), 0, 0.1D, 0)
+        world.spawnParticle("bubble", this.xCoord + worldObj.rand.nextInt(5), this.yCoord, this.zCoord + worldObj.rand.nextInt(5), 0, 0, 0)
+      }
+    }
+  }
+
+  override def getMultiBlock: MultiBlockHandler[TileReactorCell] = multiBlock
+
+  override def getWorld: World =
+  {
+    return worldObj
+  }
+
+  private def meltDown()
+  {
+    if (!worldObj.isRemote)
+    {
+      this.worldObj.setBlock(this.xCoord, this.yCoord, this.zCoord, Blocks.lava)
+      //val reactorExplosion: ReactorExplosion = new ReactorExplosion(worldObj, null, xCoord, yCoord, zCoord, 9f)
+      //reactorExplosion.doExplosionA
+      //reactorExplosion.doExplosionB(true)
+    }
+  }
+
+  def onMultiBlockChanged()
+  {
+  }
+
+  override def getMultiBlockVectors: java.lang.Iterable[Vector3] =
+  {
+    val vectors: List[Vector3] = new util.ArrayList[Vector3]
+    val checkPosition: Vector3 = toVector3
+    while (true)
+    {
+      val t: TileEntity = checkPosition.getTileEntity(this.worldObj)
+      if (t.isInstanceOf[TileReactorCell])
+      {
+        vectors.add(checkPosition - getPosition)
+      }
+      else
+      {
+        return vectors
+      }
+      checkPosition.y += 1
+    }
+    return vectors
+  }
+
+  def getPosition: Vector3 =
+  {
+    return toVector3
+  }
+
+  override def readFromNBT(nbt: NBTTagCompound)
+  {
+    super.readFromNBT(nbt)
+    getMultiBlock.load(nbt)
+  }
+
+  override def writeToNBT(nbt: NBTTagCompound)
+  {
+    super.writeToNBT(nbt)
+    getMultiBlock.save(nbt)
+  }
+
+  override def getInventoryStackLimit: Int = 1
+
+  /** Returns true if automation can insert the given item in the given slot from the given side.
+    * Args: Slot, item, side */
+  override def canInsertItem(slot: Int, items: ItemStack, side: Int): Boolean =
+  {
+    return this.isItemValidForSlot(slot, items)
+  }
+
+  override def isItemValidForSlot(slotID: Int, itemStack: ItemStack): Boolean =
+  {
+    if (getMultiBlock.isPrimary && getMultiBlock.get.getStackInSlot(0) == null)
+    {
+      return itemStack.getItem.isInstanceOf[IReactorComponent]
+    }
+    return false
+  }
+
+  override def isUseableByPlayer(par1EntityPlayer: EntityPlayer): Boolean =
+  {
+    return if (worldObj.getTileEntity(xCoord, yCoord, zCoord) ne this) false else par1EntityPlayer.getDistanceSq(xCoord + 0.5D, yCoord + 0.5D, zCoord + 0.5D) <= 64.0D
+  }
+
+  def getInvName: String =
+  {
+    return getBlockType.getLocalizedName
+  }
+
+  @SideOnly(Side.CLIENT)
+  override def getRenderBoundingBox: AxisAlignedBB =
+  {
+    if (getMultiBlock.isPrimary && getMultiBlock.isConstructed)
+    {
+      return AxisAlignedBB.getBoundingBox(x - 5, y - 5, z - 5, x + 5, y + 5, z + 5);
+    }
+    return super.getRenderBoundingBox
+  }
+
+  override def heat(energy: Double)
+  {
+    internalEnergy = Math.max(internalEnergy + energy, 0)
+  }
+
+  override def renderDynamic(pos: Vector3, frame: Float, pass: Int): Unit =
+  {
+    GL11.glPushMatrix()
+    GL11.glTranslated(x + 0.5, y + 0.5, z + 0.5)
+    val meta = if (frame != 0) metadata else 2
+
+    val hasBelow = if (frame != 0) world.getTileEntity(xi, yi - 1, zi).isInstanceOf[TileReactorCell] else false
+
+    if (meta == 0)
+    {
+      RenderUtility.bind(TileReactorCell.textureBottom)
+      TileReactorCell.modelBottom.renderAll
+    }
+    else if (meta == 1)
+    {
+      RenderUtility.bind(TileReactorCell.textureMiddle)
+      GL11.glTranslatef(0, 0.075f, 0)
+      GL11.glScalef(1f, 1.15f, 1f)
+      TileReactorCell.modelMiddle.renderAll
+    }
+    else
+    {
+      RenderUtility.bind(TileReactorCell.textureTop)
+
+      if (hasBelow)
+      {
+        GL11.glScalef(1f, 1.32f, 1f)
+      }
+      else
+      {
+        GL11.glTranslatef(0, 0.1f, 0)
+        GL11.glScalef(1f, 1.2f, 1f)
+      }
+
+      if (hasBelow)
+      {
+        TileReactorCell.modelTop.renderAllExcept("BottomPad", "BaseDepth", "BaseWidth", "Base")
+      }
+      else
+      {
+        TileReactorCell.modelTop.renderAll()
+      }
+    }
+    GL11.glPopMatrix()
+
+    if (getStackInSlot(0) != null)
+    {
+      val height = getHeight * ((getStackInSlot(0).getMaxDamage - getStackInSlot(0).getItemDamage).toFloat / getStackInSlot(0).getMaxDamage.toFloat)
+      GL11.glPushMatrix()
+      GL11.glTranslated(x + 0.5, y + 0.5 * height, z + 0.5)
+      GL11.glScalef(0.4f, 0.9f * height, 0.4f)
+      RenderUtility.bind(TileReactorCell.textureFuel)
+      RenderUtility.disableLighting()
+      ModelCube.INSTNACE.render()
+      RenderUtility.enableLighting()
+      GL11.glPopMatrix()
+    }
+  }
+
+  def getHeight: Int =
+  {
+    var height: Int = 0
+    val checkPosition: Vector3 = toVector3
+    var tile: TileEntity = this
+    while (tile.isInstanceOf[TileReactorCell])
+    {
+      checkPosition.y += 1
+      height += 1
+      tile = checkPosition.getTileEntity(worldObj)
+    }
+    return height
+  }
+
+  /** Called when the block is right clicked by the player */
+  override protected def use(player: EntityPlayer, side: Int, hit: Vector3): Boolean =
+  {
+    if (!world.isRemote)
+    {
+      val tile: TileReactorCell = getMultiBlock.get()
+      if (player.inventory.getCurrentItem != null)
+      {
+        if (tile.getStackInSlot(0) == null)
+        {
+          if (player.inventory.getCurrentItem.getItem.isInstanceOf[IReactorComponent])
+          {
+            val itemStack: ItemStack = player.inventory.getCurrentItem.copy
+            itemStack.stackSize = 1
+            tile.setInventorySlotContents(0, itemStack)
+            player.inventory.decrStackSize(player.inventory.currentItem, 1)
+            return true
+          }
+        }
+      }
+      else if (player.isSneaking && tile.getStackInSlot(0) != null)
+      {
+        InventoryUtility.dropItemStack(world, new Vector3(player), tile.getStackInSlot(0), 0)
+        tile.setInventorySlotContents(0, null)
+        return true
+      }
+      else
+      {
+        player.openGui(Electrodynamics, 0, world, tile.xCoord, tile.yCoord, tile.zCoord)
+      }
+    }
+
+    return false
+  }
+}
\ No newline at end of file