Disassembler configurable via IMC, finally!

Using that for special disassembly stuff like things built in assembler.

src/main/resources/assets/opencomputers/recipes/default.recipes

@@ -22,7 +22,7 @@ microcontrollerCase1 {
           [nuggetIron, "oc:materialCircuitBoardPrinted", nuggetIron]]
 }
 microcontrollerCase2 {
-  input: [[nuggetGold, "oc:circuitChip2", nuggetGold]
+  input: [[nuggetGold, "oc:circuitChip3", nuggetGold]
           [blockRedstone, chest, blockRedstone]
           [nuggetGold, "oc:materialCircuitBoardPrinted", nuggetGold]]
 }

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

@@ -32,13 +32,20 @@ object OpenComputers {
   def preInit(e: FMLPreInitializationEvent) {
     log = e.getModLog
     proxy.preInit(e)
+    OpenComputers.log.info("Done with pre init phase.")
   }
 
   @EventHandler
-  def init(e: FMLInitializationEvent) = proxy.init(e)
+  def init(e: FMLInitializationEvent) = {
+    proxy.init(e)
+    OpenComputers.log.info("Done with init phase.")
+  }
 
   @EventHandler
-  def postInit(e: FMLPostInitializationEvent) = proxy.postInit(e)
+  def postInit(e: FMLPostInitializationEvent) = {
+    proxy.postInit(e)
+    OpenComputers.log.info("Done with post init phase.")
+  }
 
   @EventHandler
   def missingMappings(e: FMLMissingMappingsEvent) = proxy.missingMappings(e)

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

@@ -8,6 +8,7 @@ import cpw.mods.fml.common.event.FMLInterModComms.IMCEvent
 import li.cil.oc.OpenComputers
 import li.cil.oc.Settings
 import li.cil.oc.common.template.AssemblerTemplates
+import li.cil.oc.common.template.DisassemblerTemplates
 import li.cil.oc.integration.util.Wrench
 import li.cil.oc.server.driver.Registry
 import net.minecraft.entity.player.EntityPlayer
@@ -28,6 +29,15 @@ object IMC {
           case t: Throwable => OpenComputers.log.warn("Failed registering assembler template.", t)
         }
       }
+      else if (message.key == "registerDisassemblerTemplate" && message.isNBTMessage) {
+        if (message.getNBTValue.hasKey("name", NBT.TAG_STRING))
+          OpenComputers.log.info(s"Registering new disassembler template '${message.getNBTValue.getString("name")}' from mod ${message.getSender}.")
+        else
+          OpenComputers.log.info(s"Registering new, unnamed disassembler template from mod ${message.getSender}.")
+        try DisassemblerTemplates.add(message.getNBTValue) catch {
+          case t: Throwable => OpenComputers.log.warn("Failed registering disassembler template.", t)
+        }
+      }
       else if (message.key == "registerToolDurabilityProvider" && message.isStringMessage) {
         OpenComputers.log.info(s"Registering new tool durability provider '${message.getStringValue}' from mod ${message.getSender}.")
         try ToolDurabilityProviders.add(getStaticMethod(message.getStringValue, classOf[ItemStack])) catch {
@@ -58,6 +68,9 @@ object IMC {
           case t: Throwable => OpenComputers.log.warn("Failed blacklisting component.", t)
         }
       }
+      else {
+        OpenComputers.log.warn(s"Got an unrecognized or invalid IMC message '${message.key}' from mod ${message.getSender}.")
+      }
     }
   }
 

src/main/scala/li/cil/oc/common/template/DisassemblerTemplates.scala

@@ -0,0 +1,40 @@
+package li.cil.oc.common.template
+
+import java.lang.reflect.Method
+
+import li.cil.oc.OpenComputers
+import li.cil.oc.common.IMC
+import net.minecraft.item.ItemStack
+import net.minecraft.nbt.NBTTagCompound
+
+import scala.collection.mutable
+
+object DisassemblerTemplates {
+  private val templates = mutable.ArrayBuffer.empty[Template]
+
+  def add(template: NBTTagCompound): Unit = try {
+    val selector = IMC.getStaticMethod(template.getString("select"), classOf[ItemStack])
+    val disassembler = IMC.getStaticMethod(template.getString("disassemble"), classOf[ItemStack], classOf[Array[ItemStack]])
+
+    templates += new Template(selector, disassembler)
+  }
+  catch {
+    case t: Throwable => OpenComputers.log.warn("Failed registering disassembler template.", t)
+  }
+
+  def select(stack: ItemStack) = templates.find(_.select(stack))
+
+  class Template(val selector: Method,
+                 val disassembler: Method) {
+    def select(stack: ItemStack) = IMC.tryInvokeStatic(selector, stack)(false)
+
+    def disassemble(stack: ItemStack, ingredients: Array[ItemStack]) = IMC.tryInvokeStatic(disassembler, stack, ingredients)(null: Array[_]) match {
+      case Array(stacks: Array[ItemStack], drops: Array[ItemStack]) => (Some(stacks), Some(drops))
+      case Array(stack: ItemStack, drops: Array[ItemStack]) => (Some(Array(stack)), Some(drops))
+      case Array(stacks: Array[ItemStack], drop: ItemStack) => (Some(stacks), Some(Array(drop)))
+      case stacks: Array[ItemStack] => (Some(stacks), None)
+      case _ => (None, None)
+    }
+  }
+
+}

src/main/scala/li/cil/oc/common/template/DroneTemplate.scala

@@ -28,6 +28,7 @@ object DroneTemplate extends Template {
   def assemble(inventory: IInventory) = {
     val items = (0 until inventory.getSizeInventory).map(inventory.getStackInSlot)
     val data = new ItemUtils.MicrocontrollerData()
+    data.tier = caseTier(inventory)
     data.components = items.drop(1).filter(_ != null).toArray
     data.storedEnergy = Settings.get.bufferDrone.toInt
     val stack = api.Items.get("drone").createItemStack(1)
@@ -37,6 +38,13 @@ object DroneTemplate extends Template {
     Array(stack, double2Double(energy))
   }
 
+  def selectDisassembler(stack: ItemStack) = api.Items.get(stack) == api.Items.get("drone")
+
+  def disassemble(stack: ItemStack, ingredients: Array[ItemStack]) = {
+    val info = new ItemUtils.MicrocontrollerData(stack)
+    Array(api.Items.get("droneCase" + (info.tier + 1)).createItemStack(1)) ++ info.components
+  }
+
   def register() {
     // Tier 1
     {
@@ -92,6 +100,16 @@ object DroneTemplate extends Template {
 
       FMLInterModComms.sendMessage("OpenComputers", "registerAssemblerTemplate", nbt)
     }
+
+    // Disassembler
+    {
+      val nbt = new NBTTagCompound()
+      nbt.setString("name", "Drone")
+      nbt.setString("select", "li.cil.oc.common.template.DroneTemplate.selectDisassembler")
+      nbt.setString("disassemble", "li.cil.oc.common.template.DroneTemplate.disassemble")
+
+      FMLInterModComms.sendMessage("OpenComputers", "registerDisassemblerTemplate", nbt)
+    }
   }
 
   override protected def maxComplexity(inventory: IInventory) = if (caseTier(inventory) == Tier.Two) 8 else 5

src/main/scala/li/cil/oc/common/template/MicrocontrollerTemplate.scala

@@ -28,6 +28,7 @@ object MicrocontrollerTemplate extends Template {
   def assemble(inventory: IInventory) = {
     val items = (0 until inventory.getSizeInventory).map(inventory.getStackInSlot)
     val data = new ItemUtils.MicrocontrollerData()
+    data.tier = caseTier(inventory)
     data.components = items.drop(1).filter(_ != null).toArray
     data.storedEnergy = Settings.get.bufferMicrocontroller.toInt
     val stack = api.Items.get("microcontroller").createItemStack(1)
@@ -37,6 +38,13 @@ object MicrocontrollerTemplate extends Template {
     Array(stack, double2Double(energy))
   }
 
+  def selectDisassembler(stack: ItemStack) = api.Items.get(stack) == api.Items.get("microcontroller")
+
+  def disassemble(stack: ItemStack, ingredients: Array[ItemStack]) = {
+    val info = new ItemUtils.MicrocontrollerData(stack)
+    Array(api.Items.get("microcontrollerCase" + (info.tier + 1)).createItemStack(1)) ++ info.components
+  }
+
   def register() {
     // Tier 1
     {
@@ -89,6 +97,16 @@ object MicrocontrollerTemplate extends Template {
 
       FMLInterModComms.sendMessage("OpenComputers", "registerAssemblerTemplate", nbt)
     }
+
+    // Disassembler
+    {
+      val nbt = new NBTTagCompound()
+      nbt.setString("name", "Microcontroller")
+      nbt.setString("select", "li.cil.oc.common.template.MicrocontrollerTemplate.selectDisassembler")
+      nbt.setString("disassemble", "li.cil.oc.common.template.MicrocontrollerTemplate.disassemble")
+
+      FMLInterModComms.sendMessage("OpenComputers", "registerDisassemblerTemplate", nbt)
+    }
   }
 
   override protected def maxComplexity(inventory: IInventory) = if (caseTier(inventory) == Tier.Two) 5 else 4

src/main/scala/li/cil/oc/common/template/NavigationUpgradeTemplate.scala

@@ -0,0 +1,33 @@
+package li.cil.oc.common.template
+
+import cpw.mods.fml.common.event.FMLInterModComms
+import li.cil.oc.api
+import li.cil.oc.util.ItemUtils
+import net.minecraft.item.ItemStack
+import net.minecraft.nbt.NBTTagCompound
+
+import scala.language.postfixOps
+
+object NavigationUpgradeTemplate {
+  def selectDisassembler(stack: ItemStack) = api.Items.get(stack) == api.Items.get("navigationUpgrade")
+
+  def disassemble(stack: ItemStack, ingredients: Array[ItemStack]) = {
+    val info = new ItemUtils.NavigationUpgradeData(stack)
+    ingredients.map {
+      case part if part.getItem == net.minecraft.init.Items.filled_map => info.map
+      case part => part
+    }
+  }
+
+  def register() {
+    // Disassembler
+    {
+      val nbt = new NBTTagCompound()
+      nbt.setString("name", "Navigation Upgrade")
+      nbt.setString("select", "li.cil.oc.common.template.NavigationUpgradeTemplate.selectDisassembler")
+      nbt.setString("disassemble", "li.cil.oc.common.template.NavigationUpgradeTemplate.disassemble")
+
+      FMLInterModComms.sendMessage("OpenComputers", "registerDisassemblerTemplate", nbt)
+    }
+  }
+}

src/main/scala/li/cil/oc/common/template/RobotTemplate.scala

@@ -42,6 +42,16 @@ object RobotTemplate extends Template {
     Array(stack, double2Double(energy))
   }
 
+  def selectDisassembler(stack: ItemStack) = api.Items.get(stack) == api.Items.get("microcontroller")
+
+  def disassemble(stack: ItemStack, ingredients: Array[ItemStack]) = {
+    val info = new ItemUtils.RobotData(stack)
+    val itemName =
+      if (info.tier == Tier.Four) "caseCreative"
+      else "case" + (info.tier + 1)
+    Array(api.Items.get(itemName).createItemStack(1)) ++ info.containers ++ info.components
+  }
+
   def register() {
     // Tier 1
     {
@@ -199,6 +209,16 @@ object RobotTemplate extends Template {
 
       FMLInterModComms.sendMessage("OpenComputers", "registerAssemblerTemplate", nbt)
     }
+
+    // Disassembler
+    {
+      val nbt = new NBTTagCompound()
+      nbt.setString("name", "Robot")
+      nbt.setString("select", "li.cil.oc.common.template.RobotTemplate.selectDisassembler")
+      nbt.setString("disassemble", "li.cil.oc.common.template.RobotTemplate.disassemble")
+
+      FMLInterModComms.sendMessage("OpenComputers", "registerDisassemblerTemplate", nbt)
+    }
   }
 
   override protected def caseTier(inventory: IInventory) = ItemUtils.caseTier(inventory.getStackInSlot(0))

src/main/scala/li/cil/oc/common/template/ServerTemplate.scala

@@ -0,0 +1,45 @@
+package li.cil.oc.common.template
+
+import cpw.mods.fml.common.event.FMLInterModComms
+import li.cil.oc.Settings
+import li.cil.oc.api
+import li.cil.oc.api.internal
+import li.cil.oc.common.Slot
+import li.cil.oc.common.Tier
+import li.cil.oc.common.inventory.ServerInventory
+import li.cil.oc.util.ExtendedNBT._
+import li.cil.oc.util.ItemUtils
+import net.minecraft.inventory.IInventory
+import net.minecraft.item.ItemStack
+import net.minecraft.nbt.NBTTagCompound
+import net.minecraft.nbt.NBTTagList
+
+import scala.language.postfixOps
+
+object ServerTemplate {
+  def selectDisassembler(stack: ItemStack) =
+    api.Items.get(stack) == api.Items.get("server1") ||
+      api.Items.get(stack) == api.Items.get("server2") ||
+      api.Items.get(stack) == api.Items.get("server3")
+
+  def disassemble(stack: ItemStack, ingredients: Array[ItemStack]) = {
+    val info = new ServerInventory {
+      override def tier = ItemUtils.caseTier(stack)
+
+      override def container = stack
+    }
+    Array(ingredients, (0 until info.getSizeInventory).map(info.getStackInSlot).filter(null !=).toArray)
+  }
+
+  def register() {
+    // Disassembler
+    {
+      val nbt = new NBTTagCompound()
+      nbt.setString("name", "Server")
+      nbt.setString("select", "li.cil.oc.common.template.ServerTemplate.selectDisassembler")
+      nbt.setString("disassemble", "li.cil.oc.common.template.ServerTemplate.disassemble")
+
+      FMLInterModComms.sendMessage("OpenComputers", "registerDisassemblerTemplate", nbt)
+    }
+  }
+}

src/main/scala/li/cil/oc/common/template/TabletTemplate.scala

@@ -42,32 +42,54 @@ object TabletTemplate extends Template {
     Array(stack, double2Double(energy))
   }
 
+  def selectDisassembler(stack: ItemStack) = api.Items.get(stack) == api.Items.get("tablet")
+
+  def disassemble(stack: ItemStack, ingredients: Array[ItemStack]) = {
+    val info = new ItemUtils.TabletData(stack)
+    Array(api.Items.get("tabletCase").createItemStack(1)) ++ info.items.collect {
+      case Some(item) => item
+    }.drop(1) // Screen.
+  }
+
   def register() {
-    val nbt = new NBTTagCompound()
+    // Tier 1
-    nbt.setString("name", "Tablet")
+    {
-    nbt.setString("select", "li.cil.oc.common.template.TabletTemplate.select")
+      val nbt = new NBTTagCompound()
-    nbt.setString("validate", "li.cil.oc.common.template.TabletTemplate.validate")
+      nbt.setString("name", "Tablet")
-    nbt.setString("assemble", "li.cil.oc.common.template.TabletTemplate.assemble")
+      nbt.setString("select", "li.cil.oc.common.template.TabletTemplate.select")
-    nbt.setString("hostClass", "li.cil.oc.api.internal.Tablet")
+      nbt.setString("validate", "li.cil.oc.common.template.TabletTemplate.validate")
+      nbt.setString("assemble", "li.cil.oc.common.template.TabletTemplate.assemble")
+      nbt.setString("hostClass", "li.cil.oc.api.internal.Tablet")
 
-    val upgradeSlots = new NBTTagList()
+      val upgradeSlots = new NBTTagList()
-    upgradeSlots.appendTag(Map("tier" -> Tier.Three))
+      upgradeSlots.appendTag(Map("tier" -> Tier.Three))
-    upgradeSlots.appendTag(Map("tier" -> Tier.Two))
+      upgradeSlots.appendTag(Map("tier" -> Tier.Two))
-    upgradeSlots.appendTag(Map("tier" -> Tier.One))
+      upgradeSlots.appendTag(Map("tier" -> Tier.One))
-    nbt.setTag("upgradeSlots", upgradeSlots)
+      nbt.setTag("upgradeSlots", upgradeSlots)
 
-    val componentSlots = new NBTTagList()
+      val componentSlots = new NBTTagList()
-    componentSlots.appendTag(Map("type" -> Slot.Card, "tier" -> Tier.Two))
+      componentSlots.appendTag(Map("type" -> Slot.Card, "tier" -> Tier.Two))
-    componentSlots.appendTag(Map("type" -> Slot.Card, "tier" -> Tier.Two))
+      componentSlots.appendTag(Map("type" -> Slot.Card, "tier" -> Tier.Two))
-    componentSlots.appendTag(new NBTTagCompound())
+      componentSlots.appendTag(new NBTTagCompound())
-    componentSlots.appendTag(Map("type" -> Slot.CPU, "tier" -> Tier.Two))
+      componentSlots.appendTag(Map("type" -> Slot.CPU, "tier" -> Tier.Two))
-    componentSlots.appendTag(Map("type" -> Slot.Memory, "tier" -> Tier.Two))
+      componentSlots.appendTag(Map("type" -> Slot.Memory, "tier" -> Tier.Two))
-    componentSlots.appendTag(Map("type" -> Slot.Memory, "tier" -> Tier.Two))
+      componentSlots.appendTag(Map("type" -> Slot.Memory, "tier" -> Tier.Two))
-    componentSlots.appendTag(Map("type" -> Slot.EEPROM, "tier" -> Tier.Any))
+      componentSlots.appendTag(Map("type" -> Slot.EEPROM, "tier" -> Tier.Any))
-    componentSlots.appendTag(Map("type" -> Slot.HDD, "tier" -> Tier.Two))
+      componentSlots.appendTag(Map("type" -> Slot.HDD, "tier" -> Tier.Two))
-    nbt.setTag("componentSlots", componentSlots)
+      nbt.setTag("componentSlots", componentSlots)
 
-    FMLInterModComms.sendMessage("OpenComputers", "registerAssemblerTemplate", nbt)
+      FMLInterModComms.sendMessage("OpenComputers", "registerAssemblerTemplate", nbt)
+    }
+
+    // Disassembler
+    {
+      val nbt = new NBTTagCompound()
+      nbt.setString("name", "Tablet")
+      nbt.setString("select", "li.cil.oc.common.template.TabletTemplate.selectDisassembler")
+      nbt.setString("disassemble", "li.cil.oc.common.template.TabletTemplate.disassemble")
+
+      FMLInterModComms.sendMessage("OpenComputers", "registerDisassemblerTemplate", nbt)
+    }
   }
 
   override protected def maxComplexity(inventory: IInventory) = super.maxComplexity(inventory) - 10

src/main/scala/li/cil/oc/common/tileentity/Disassembler.scala

@@ -6,8 +6,7 @@ import li.cil.oc.OpenComputers
 import li.cil.oc.Settings
 import li.cil.oc.api
 import li.cil.oc.api.network.Visibility
-import li.cil.oc.common.Tier
+import li.cil.oc.common.template.DisassemblerTemplates
-import li.cil.oc.common.inventory.ServerInventory
 import li.cil.oc.server.{PacketSender => ServerPacketSender}
 import li.cil.oc.util.BlockPosition
 import li.cil.oc.util.ExtendedNBT._
@@ -91,66 +90,17 @@ class Disassembler extends traits.Environment with traits.PowerAcceptor with tra
   def disassemble(stack: ItemStack) {
     // Validate the item, never trust Minecraft / other Mods on anything!
     if (stack != null && isItemValidForSlot(0, stack)) {
-      if (api.Items.get(stack) == api.Items.get("robot")) enqueueRobot(stack)
+      DisassemblerTemplates.select(stack) match {
-      else if (api.Items.get(stack) == api.Items.get("server1")) enqueueServer(stack, 0)
+        case Some(template) =>
-      else if (api.Items.get(stack) == api.Items.get("server2")) enqueueServer(stack, 1)
+          val (stacks, drops) = template.disassemble(stack, getIngredients(stack).toArray)
-      else if (api.Items.get(stack) == api.Items.get("server3")) enqueueServer(stack, 2)
+          stacks.foreach(queue ++= _)
-      else if (api.Items.get(stack) == api.Items.get("tablet")) enqueueTablet(stack)
+          drops.foreach(_.foreach(drop))
-      else if (api.Items.get(stack) == api.Items.get("microcontroller")) enqueueMicrocontroller(stack)
+        case _ => queue ++= getIngredients(stack)
-      else if (api.Items.get(stack) == api.Items.get("navigationUpgrade")) enqueueNavigationUpgrade(stack)
+      }
-      else queue ++= getIngredients(stack)
       totalRequiredEnergy = queue.size * Settings.get.disassemblerItemCost
     }
   }
 
-  private def enqueueRobot(robot: ItemStack) {
-    val info = new ItemUtils.RobotData(robot)
-    val itemName =
-      if (info.tier == Tier.Four) "caseCreative"
-      else "case" + (info.tier + 1)
-    queue += api.Items.get(itemName).createItemStack(1)
-    queue ++= info.containers
-    queue ++= info.components
-    node.changeBuffer(info.robotEnergy)
-  }
-
-  private def enqueueServer(server: ItemStack, serverTier: Int) {
-    val info = new ServerInventory {
-      override def tier = serverTier
-
-      override def container = server
-    }
-    for (slot <- 0 until info.getSizeInventory) {
-      val stack = info.getStackInSlot(slot)
-      drop(stack)
-    }
-    queue ++= getIngredients(server)
-  }
-
-  private def enqueueTablet(tablet: ItemStack) {
-    val info = new ItemUtils.TabletData(tablet)
-    queue += api.Items.get("tabletCase").createItemStack(1)
-    queue ++= info.items.collect {
-      case Some(stack) => stack
-    }.drop(1) // Screen.
-    node.changeBuffer(info.energy)
-  }
-
-  private def enqueueMicrocontroller(mcu: ItemStack) {
-    val info = new ItemUtils.MicrocontrollerData(mcu)
-    queue += api.Items.get("microcontrollerCase").createItemStack(1)
-    queue ++= info.components
-  }
-
-  private def enqueueNavigationUpgrade(stack: ItemStack) {
-    val info = new ItemUtils.NavigationUpgradeData(stack)
-    val parts = getIngredients(stack)
-    queue ++= parts.map {
-      case part if part.getItem == net.minecraft.init.Items.filled_map => info.map
-      case part => part
-    }
-  }
-
   private def getIngredients(stack: ItemStack): Iterable[ItemStack] = try {
     val recipes = CraftingManager.getInstance.getRecipeList.map(_.asInstanceOf[IRecipe])
     val recipe = recipes.find(recipe => recipe.getRecipeOutput != null && recipe.getRecipeOutput.isItemEqual(stack))
@@ -250,7 +200,5 @@ class Disassembler extends traits.Environment with traits.PowerAcceptor with tra
 
   override def isItemValidForSlot(i: Int, stack: ItemStack) =
     ((Settings.get.disassembleAllTheThings || api.Items.get(stack) != null) && getIngredients(stack).nonEmpty) ||
-      api.Items.get(stack) == api.Items.get("robot") ||
+      DisassemblerTemplates.select(stack) != null
-      api.Items.get(stack) == api.Items.get("tablet") ||
-      api.Items.get(stack) == api.Items.get("microcontroller")
 }

src/main/scala/li/cil/oc/integration/opencomputers/ModOpenComputers.scala

@@ -14,10 +14,7 @@ import li.cil.oc.common.entity.Drone
 import li.cil.oc.common.event._
 import li.cil.oc.common.item.Tablet
 import li.cil.oc.common.recipe.Recipes
-import li.cil.oc.common.template.DroneTemplate
+import li.cil.oc.common.template._
-import li.cil.oc.common.template.MicrocontrollerTemplate
-import li.cil.oc.common.template.RobotTemplate
-import li.cil.oc.common.template.TabletTemplate
 import li.cil.oc.integration.ModProxy
 import li.cil.oc.integration.Mods
 import li.cil.oc.integration.util.WirelessRedstone
@@ -33,7 +30,9 @@ object ModOpenComputers extends ModProxy {
   override def initialize() {
     DroneTemplate.register()
     MicrocontrollerTemplate.register()
+    NavigationUpgradeTemplate.register()
     RobotTemplate.register()
+    ServerTemplate.register()
     TabletTemplate.register()
 
     Loot.init()

src/main/scala/li/cil/oc/util/ItemUtils.scala

@@ -30,6 +30,9 @@ object ItemUtils {
     else if (descriptor == api.Items.get("microcontrollerCase2")) Tier.Two
     else if (descriptor == api.Items.get("droneCase1")) Tier.One
     else if (descriptor == api.Items.get("droneCase2")) Tier.Two
+    else if (descriptor == api.Items.get("server1")) Tier.One
+    else if (descriptor == api.Items.get("server2")) Tier.Two
+    else if (descriptor == api.Items.get("server3")) Tier.Three
     else Tier.None
   }
 
@@ -58,17 +61,21 @@ object ItemUtils {
       load(stack)
     }
 
+    var tier = Tier.One
+
     var components = Array.empty[ItemStack]
 
     var storedEnergy = 0
 
     override def load(nbt: NBTTagCompound) {
+      tier = nbt.getByte(Settings.namespace + "tier")
       components = nbt.getTagList(Settings.namespace + "components", NBT.TAG_COMPOUND).
         toArray[NBTTagCompound].map(loadStack)
       storedEnergy = nbt.getInteger(Settings.namespace + "storedEnergy")
     }
 
     override def save(nbt: NBTTagCompound) {
+      nbt.setByte(Settings.namespace + "tier", tier.toByte)
       nbt.setNewTagList(Settings.namespace + "components", components.toIterable)
       nbt.setInteger(Settings.namespace + "storedEnergy", storedEnergy)
     }