From 856b5fd275f804f134ab39a34aa9e2635f10cdf9 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Florian=20N=C3=BCcke?= Date: Sun, 21 Dec 2014 18:11:32 +0100 Subject: [PATCH] Disassembler configurable via IMC, finally! Using that for special disassembly stuff like things built in assembler. --- .../opencomputers/recipes/default.recipes | 2 +- src/main/scala/li/cil/oc/OpenComputers.scala | 11 ++- src/main/scala/li/cil/oc/common/IMC.scala | 13 ++++ .../template/DisassemblerTemplates.scala | 40 +++++++++++ .../oc/common/template/DroneTemplate.scala | 18 +++++ .../template/MicrocontrollerTemplate.scala | 18 +++++ .../template/NavigationUpgradeTemplate.scala | 33 +++++++++ .../oc/common/template/RobotTemplate.scala | 20 ++++++ .../oc/common/template/ServerTemplate.scala | 45 ++++++++++++ .../oc/common/template/TabletTemplate.scala | 66 +++++++++++------ .../oc/common/tileentity/Disassembler.scala | 70 +++---------------- .../opencomputers/ModOpenComputers.scala | 7 +- src/main/scala/li/cil/oc/util/ItemUtils.scala | 7 ++ 13 files changed, 260 insertions(+), 90 deletions(-) create mode 100644 src/main/scala/li/cil/oc/common/template/DisassemblerTemplates.scala create mode 100644 src/main/scala/li/cil/oc/common/template/NavigationUpgradeTemplate.scala create mode 100644 src/main/scala/li/cil/oc/common/template/ServerTemplate.scala diff --git a/src/main/resources/assets/opencomputers/recipes/default.recipes b/src/main/resources/assets/opencomputers/recipes/default.recipes index 23da70c8b..ec4f49043 100644 --- a/src/main/resources/assets/opencomputers/recipes/default.recipes +++ b/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]] } diff --git a/src/main/scala/li/cil/oc/OpenComputers.scala b/src/main/scala/li/cil/oc/OpenComputers.scala index d91167ae3..8d18f839a 100644 --- a/src/main/scala/li/cil/oc/OpenComputers.scala +++ b/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) diff --git a/src/main/scala/li/cil/oc/common/IMC.scala b/src/main/scala/li/cil/oc/common/IMC.scala index 571116f6c..a1522fa12 100644 --- a/src/main/scala/li/cil/oc/common/IMC.scala +++ b/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}.") + } } } diff --git a/src/main/scala/li/cil/oc/common/template/DisassemblerTemplates.scala b/src/main/scala/li/cil/oc/common/template/DisassemblerTemplates.scala new file mode 100644 index 000000000..42a473361 --- /dev/null +++ b/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) + } + } + +} diff --git a/src/main/scala/li/cil/oc/common/template/DroneTemplate.scala b/src/main/scala/li/cil/oc/common/template/DroneTemplate.scala index 854347508..0f8c0c1a0 100644 --- a/src/main/scala/li/cil/oc/common/template/DroneTemplate.scala +++ b/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 diff --git a/src/main/scala/li/cil/oc/common/template/MicrocontrollerTemplate.scala b/src/main/scala/li/cil/oc/common/template/MicrocontrollerTemplate.scala index fd499000f..d528ca100 100644 --- a/src/main/scala/li/cil/oc/common/template/MicrocontrollerTemplate.scala +++ b/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 diff --git a/src/main/scala/li/cil/oc/common/template/NavigationUpgradeTemplate.scala b/src/main/scala/li/cil/oc/common/template/NavigationUpgradeTemplate.scala new file mode 100644 index 000000000..282eac6c1 --- /dev/null +++ b/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) + } + } +} diff --git a/src/main/scala/li/cil/oc/common/template/RobotTemplate.scala b/src/main/scala/li/cil/oc/common/template/RobotTemplate.scala index d576e37ef..e4d3842fb 100644 --- a/src/main/scala/li/cil/oc/common/template/RobotTemplate.scala +++ b/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)) diff --git a/src/main/scala/li/cil/oc/common/template/ServerTemplate.scala b/src/main/scala/li/cil/oc/common/template/ServerTemplate.scala new file mode 100644 index 000000000..68369842a --- /dev/null +++ b/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) + } + } +} diff --git a/src/main/scala/li/cil/oc/common/template/TabletTemplate.scala b/src/main/scala/li/cil/oc/common/template/TabletTemplate.scala index 425c6467c..144962d32 100644 --- a/src/main/scala/li/cil/oc/common/template/TabletTemplate.scala +++ b/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() - nbt.setString("name", "Tablet") - nbt.setString("select", "li.cil.oc.common.template.TabletTemplate.select") - 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") + // Tier 1 + { + val nbt = new NBTTagCompound() + nbt.setString("name", "Tablet") + nbt.setString("select", "li.cil.oc.common.template.TabletTemplate.select") + 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() - upgradeSlots.appendTag(Map("tier" -> Tier.Three)) - upgradeSlots.appendTag(Map("tier" -> Tier.Two)) - upgradeSlots.appendTag(Map("tier" -> Tier.One)) - nbt.setTag("upgradeSlots", upgradeSlots) + val upgradeSlots = new NBTTagList() + upgradeSlots.appendTag(Map("tier" -> Tier.Three)) + upgradeSlots.appendTag(Map("tier" -> Tier.Two)) + upgradeSlots.appendTag(Map("tier" -> Tier.One)) + nbt.setTag("upgradeSlots", upgradeSlots) - val componentSlots = new NBTTagList() - componentSlots.appendTag(Map("type" -> Slot.Card, "tier" -> Tier.Two)) - componentSlots.appendTag(Map("type" -> Slot.Card, "tier" -> Tier.Two)) - componentSlots.appendTag(new NBTTagCompound()) - 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.EEPROM, "tier" -> Tier.Any)) - componentSlots.appendTag(Map("type" -> Slot.HDD, "tier" -> Tier.Two)) - nbt.setTag("componentSlots", componentSlots) + val componentSlots = new NBTTagList() + componentSlots.appendTag(Map("type" -> Slot.Card, "tier" -> Tier.Two)) + componentSlots.appendTag(Map("type" -> Slot.Card, "tier" -> Tier.Two)) + componentSlots.appendTag(new NBTTagCompound()) + 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.EEPROM, "tier" -> Tier.Any)) + componentSlots.appendTag(Map("type" -> Slot.HDD, "tier" -> Tier.Two)) + 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 diff --git a/src/main/scala/li/cil/oc/common/tileentity/Disassembler.scala b/src/main/scala/li/cil/oc/common/tileentity/Disassembler.scala index 590c7b96e..8894bca4f 100644 --- a/src/main/scala/li/cil/oc/common/tileentity/Disassembler.scala +++ b/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.inventory.ServerInventory +import li.cil.oc.common.template.DisassemblerTemplates 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) - else if (api.Items.get(stack) == api.Items.get("server1")) enqueueServer(stack, 0) - else if (api.Items.get(stack) == api.Items.get("server2")) enqueueServer(stack, 1) - else if (api.Items.get(stack) == api.Items.get("server3")) enqueueServer(stack, 2) - else if (api.Items.get(stack) == api.Items.get("tablet")) enqueueTablet(stack) - else if (api.Items.get(stack) == api.Items.get("microcontroller")) enqueueMicrocontroller(stack) - else if (api.Items.get(stack) == api.Items.get("navigationUpgrade")) enqueueNavigationUpgrade(stack) - else queue ++= getIngredients(stack) + DisassemblerTemplates.select(stack) match { + case Some(template) => + val (stacks, drops) = template.disassemble(stack, getIngredients(stack).toArray) + stacks.foreach(queue ++= _) + drops.foreach(_.foreach(drop)) + case _ => 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") || - api.Items.get(stack) == api.Items.get("tablet") || - api.Items.get(stack) == api.Items.get("microcontroller") + DisassemblerTemplates.select(stack) != null } diff --git a/src/main/scala/li/cil/oc/integration/opencomputers/ModOpenComputers.scala b/src/main/scala/li/cil/oc/integration/opencomputers/ModOpenComputers.scala index 51869927d..d4df3e5f3 100644 --- a/src/main/scala/li/cil/oc/integration/opencomputers/ModOpenComputers.scala +++ b/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.MicrocontrollerTemplate -import li.cil.oc.common.template.RobotTemplate -import li.cil.oc.common.template.TabletTemplate +import li.cil.oc.common.template._ 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() diff --git a/src/main/scala/li/cil/oc/util/ItemUtils.scala b/src/main/scala/li/cil/oc/util/ItemUtils.scala index 5f6af3d2f..078ba03fb 100644 --- a/src/main/scala/li/cil/oc/util/ItemUtils.scala +++ b/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) }