| package li.cil.oc |
| |
| import com.typesafe.config._ |
| import cpw.mods.fml.common.Loader |
| import cpw.mods.fml.common.registry.GameRegistry |
| import java.io.{FileReader, File} |
| import java.util.logging.Level |
| import li.cil.oc.common.block.Delegator |
| import li.cil.oc.util.mods.{StargateTech2, GregTech} |
| import net.minecraft.block.Block |
| import net.minecraft.item.crafting.FurnaceRecipes |
| import net.minecraft.item.{ItemStack, Item} |
| import net.minecraftforge.oredict.{OreDictionary, ShapelessOreRecipe, ShapedOreRecipe} |
| import org.apache.commons.io.FileUtils |
| import scala.Some |
| import scala.collection.convert.wrapAsScala._ |
| import scala.collection.mutable.ArrayBuffer |
| |
| object Recipes { |
| def init() { |
| try { |
| val defaultRecipes = new File(Loader.instance.getConfigDir + File.separator + "opencomputers" + File.separator + "default.recipes") |
| val hardmodeRecipes = new File(Loader.instance.getConfigDir + File.separator + "opencomputers" + File.separator + "hardmode.recipes") |
| val gregTechRecipes = new File(Loader.instance.getConfigDir + File.separator + "opencomputers" + File.separator + "gregtech.recipes") |
| val userRecipes = new File(Loader.instance.getConfigDir + File.separator + "opencomputers" + File.separator + "user.recipes") |
| |
| defaultRecipes.getParentFile.mkdirs() |
| FileUtils.copyURLToFile(getClass.getResource("/assets/opencomputers/recipes/default.recipes"), defaultRecipes) |
| FileUtils.copyURLToFile(getClass.getResource("/assets/opencomputers/recipes/hardmode.recipes"), hardmodeRecipes) |
| FileUtils.copyURLToFile(getClass.getResource("/assets/opencomputers/recipes/gregtech.recipes"), gregTechRecipes) |
| if (!userRecipes.exists()) { |
| FileUtils.copyURLToFile(getClass.getResource("/assets/opencomputers/recipes/user.recipes"), userRecipes) |
| } |
| val config = ConfigParseOptions.defaults. |
| setSyntax(ConfigSyntax.CONF). |
| setIncluder(new ConfigIncluder with ConfigIncluderFile { |
| var fallback: ConfigIncluder = _ |
| |
| override def withFallback(fallback: ConfigIncluder) = { |
| this.fallback = fallback |
| this |
| } |
| |
| override def include(context: ConfigIncludeContext, what: String) = fallback.include(context, what) |
| |
| override def includeFile(context: ConfigIncludeContext, what: File) = { |
| val in = if (what.isAbsolute) new FileReader(what) else new FileReader(new File(userRecipes.getParentFile, what.getPath)) |
| val result = ConfigFactory.parseReader(in) |
| in.close() |
| result.root() |
| } |
| }) |
| val recipes = ConfigFactory.parseFile(userRecipes, config) |
| |
| // Try to keep this in the same order as the fields in the Items class |
| // to make it easier to match them and check if anything is missing. |
| addRecipe(Items.analyzer.createItemStack(), recipes, "analyzer") |
| addRecipe(Items.terminal.createItemStack(), recipes, "terminal") |
| |
| addRecipe(Items.ram1.createItemStack(), recipes, "ram1") |
| addRecipe(Items.ram2.createItemStack(), recipes, "ram2") |
| addRecipe(Items.ram3.createItemStack(), recipes, "ram3") |
| addRecipe(Items.ram4.createItemStack(), recipes, "ram4") |
| addRecipe(Items.ram5.createItemStack(), recipes, "ram5") |
| |
| addRecipe(Items.floppyDisk.createItemStack(), recipes, "floppy") |
| addRecipe(Items.hdd1.createItemStack(), recipes, "hdd1") |
| addRecipe(Items.hdd2.createItemStack(), recipes, "hdd2") |
| addRecipe(Items.hdd3.createItemStack(), recipes, "hdd3") |
| |
| addRecipe(Items.server1.createItemStack(), recipes, "server1") |
| addRecipe(Items.server2.createItemStack(), recipes, "server2") |
| addRecipe(Items.server3.createItemStack(), recipes, "server3") |
| |
| if (StargateTech2.isAvailable) { |
| addRecipe(Items.abstractBus.createItemStack(), recipes, "abstractBusCard") |
| } |
| addRecipe(Items.gpu1.createItemStack(), recipes, "graphicsCard1") |
| addRecipe(Items.gpu2.createItemStack(), recipes, "graphicsCard2") |
| addRecipe(Items.gpu3.createItemStack(), recipes, "graphicsCard3") |
| addRecipe(Items.internet.createItemStack(), recipes, "internetCard") |
| addRecipe(Items.lan.createItemStack(), recipes, "lanCard") |
| addRecipe(Items.rs.createItemStack(), recipes, "redstoneCard") |
| addRecipe(Items.wlan.createItemStack(), recipes, "wlanCard") |
| |
| addRecipe(Items.upgradeCrafting.createItemStack(), recipes, "craftingUpgrade") |
| addRecipe(Items.upgradeGenerator.createItemStack(), recipes, "generatorUpgrade") |
| addRecipe(Items.upgradeNavigation.createItemStack(), recipes, "navigationUpgrade") |
| addRecipe(Items.upgradeSign.createItemStack(), recipes, "signUpgrade") |
| addRecipe(Items.upgradeSolarGenerator.createItemStack(), recipes, "solarGeneratorUpgrade") |
| |
| if (OreDictionary.getOres("nuggetIron").exists(Items.ironNugget.createItemStack().isItemEqual)) { |
| addRecipe(Items.ironNugget.createItemStack(), recipes, "nuggetIron") |
| } |
| addRecipe(Items.cuttingWire.createItemStack(), recipes, "cuttingWire") |
| addRecipe(Items.acid.createItemStack(), recipes, "acid") |
| addRecipe(Items.disk.createItemStack(), recipes, "disk") |
| |
| addRecipe(Items.buttonGroup.createItemStack(), recipes, "buttonGroup") |
| addRecipe(Items.arrowKeys.createItemStack(), recipes, "arrowKeys") |
| addRecipe(Items.numPad.createItemStack(), recipes, "numPad") |
| |
| addRecipe(Items.transistor.createItemStack(), recipes, "transistor") |
| addRecipe(Items.chip1.createItemStack(), recipes, "chip1") |
| addRecipe(Items.chip2.createItemStack(), recipes, "chip2") |
| addRecipe(Items.chip3.createItemStack(), recipes, "chip3") |
| addRecipe(Items.alu.createItemStack(), recipes, "alu") |
| addRecipe(Items.cpu0.createItemStack(), recipes, "cpu0") |
| addRecipe(Items.cpu1.createItemStack(), recipes, "cpu1") |
| addRecipe(Items.cpu2.createItemStack(), recipes, "cpu2") |
| addRecipe(Items.cu.createItemStack(), recipes, "cu") |
| |
| addRecipe(Items.rawCircuitBoard.createItemStack(), recipes, "rawCircuitBoard") |
| addRecipe(Items.circuitBoard.createItemStack(), recipes, "circuitBoard") |
| addRecipe(Items.pcb.createItemStack(), recipes, "printedCircuitBoard") |
| addRecipe(Items.card.createItemStack(), recipes, "card") |
| |
| // Try to keep this in the same order as the fields in the Blocks class |
| // to make it easier to match them and check if anything is missing.Point") |
| addRecipe(Blocks.adapter.createItemStack(), recipes, "adapter") |
| addRecipe(Blocks.cable.createItemStack(), recipes, "cable") |
| addRecipe(Blocks.capacitor.createItemStack(), recipes, "capacitor") |
| addRecipe(Blocks.charger.createItemStack(), recipes, "charger") |
| addRecipe(Blocks.case1.createItemStack(), recipes, "case1") |
| addRecipe(Blocks.case2.createItemStack(), recipes, "case2") |
| addRecipe(Blocks.case3.createItemStack(), recipes, "case3") |
| addRecipe(Blocks.diskDrive.createItemStack(), recipes, "diskDrive") |
| addRecipe(Blocks.keyboard.createItemStack(), recipes, "keyboard") |
| addRecipe(Blocks.powerConverter.createItemStack(), recipes, "powerConverter") |
| addRecipe(Blocks.powerDistributor.createItemStack(), recipes, "powerDistributor") |
| addRecipe(Blocks.redstone.createItemStack(), recipes, "redstone") |
| addRecipe(Blocks.robotProxy.createItemStack(), recipes, "robot") |
| addRecipe(Blocks.router.createItemStack(), recipes, "router") |
| addRecipe(Blocks.screen1.createItemStack(), recipes, "screen1") |
| addRecipe(Blocks.screen2.createItemStack(), recipes, "screen2") |
| addRecipe(Blocks.screen3.createItemStack(), recipes, "screen3") |
| addRecipe(Blocks.serverRack.createItemStack(), recipes, "rack") |
| |
| // Navigation upgrade recrafting. |
| GameRegistry.addRecipe(new ShapelessOreRecipe(Items.upgradeNavigation.createItemStack(), Items.upgradeNavigation.createItemStack(), new ItemStack(net.minecraft.init.Items.map, 1, OreDictionary.WILDCARD_VALUE))) |
| } |
| catch { |
| case e: Throwable => OpenComputers.log.log(Level.SEVERE, "Error parsing recipes, you may not be able to craft any items from this mod!", e) |
| } |
| } |
| |
| def addRecipe(output: ItemStack, list: Config, name: String) = try { |
| if (list.hasPath(name)) { |
| val recipe = list.getConfig(name) |
| val recipeType = tryGetType(recipe) |
| try { |
| recipeType match { |
| case "shaped" => addShapedRecipe(output, recipe) |
| case "shapeless" => addShapelessRecipe(output, recipe) |
| case "furnace" => addFurnaceRecipe(output, recipe) |
| case "assembly" => addAssemblyRecipe(output, recipe) |
| case other => |
| OpenComputers.log.warning("Failed adding recipe for '" + name + "', you will not be able to craft this item! The error was: Invalid recipe type '" + other + "'.") |
| hide(output) |
| } |
| } |
| catch { |
| case e: RecipeException => |
| OpenComputers.log.warning("Failed adding " + recipeType + " recipe for '" + name + "', you will not be able to craft this item! The error was: " + e.getMessage) |
| hide(output) |
| } |
| } |
| else { |
| OpenComputers.log.info("No recipe for '" + name + "', you will not be able to craft this item.") |
| hide(output) |
| } |
| } |
| catch { |
| case e: Throwable => |
| OpenComputers.log.log(Level.SEVERE, "Failed adding recipe for '" + name + "', you will not be able to craft this item!", e) |
| hide(output) |
| } |
| |
| private def addShapedRecipe(output: ItemStack, recipe: Config) { |
| val rows = recipe.getList("input").unwrapped().map { |
| case row: java.util.List[AnyRef]@unchecked => row.map(parseIngredient) |
| case other => throw new RecipeException("Invalid row entry for shaped recipe (not a list: " + other + ").") |
| } |
| output.stackSize = tryGetCount(recipe) |
| |
| var number = -1 |
| var shape = ArrayBuffer.empty[String] |
| val input = ArrayBuffer.empty[AnyRef] |
| for (row <- rows) { |
| val (pattern, ingredients) = row.foldLeft((new StringBuilder, Seq.empty[AnyRef]))((acc, ingredient) => { |
| val (pattern, ingredients) = acc |
| ingredient match { |
| case _@(_: ItemStack | _: String) => |
| number += 1 |
| (pattern.append(('a' + number).toChar), ingredients ++ Seq(Char.box(('a' + number).toChar), ingredient)) |
| case _ => (pattern.append(' '), ingredients) |
| } |
| }) |
| shape += pattern.toString |
| input ++= ingredients |
| } |
| if (input.size > 0 && output.stackSize > 0) { |
| GameRegistry.addRecipe(new ShapedOreRecipe(output, shape ++ input: _*)) |
| } |
| else hide(output) |
| } |
| |
| private def addShapelessRecipe(output: ItemStack, recipe: Config) { |
| val input = recipe.getValue("input").unwrapped() match { |
| case list: java.util.List[AnyRef]@unchecked => list.map(parseIngredient) |
| case other => Seq(parseIngredient(other)) |
| } |
| output.stackSize = tryGetCount(recipe) |
| |
| if (input.size > 0 && output.stackSize > 0) { |
| GameRegistry.addRecipe(new ShapelessOreRecipe(output, input: _*)) |
| } |
| else hide(output) |
| } |
| |
| private def addAssemblyRecipe(output: ItemStack, recipe: Config) { |
| val input = (recipe.getValue("input").unwrapped() match { |
| case list: java.util.List[AnyRef]@unchecked => list.map(parseIngredient) |
| case other => Seq(parseIngredient(other)) |
| }) map { |
| case stack: ItemStack => stack |
| case null => null |
| case name: String => throw new RecipeException("Invalid ingredient '" + name + "', OreDictionary not supported for assembly recipes.") |
| case other => throw new RecipeException("Invalid ingredient type: " + other + ".") |
| } |
| output.stackSize = tryGetCount(recipe) |
| |
| if (input.size < 1 || input.size > 2) { |
| throw new RecipeException("Invalid recipe length: " + input.size + ", should be 1 or 2.") |
| } |
| |
| val inputCount = recipe.getIntList("count") |
| if (inputCount.size() != input.size) { |
| throw new RecipeException("Ingredient and input count mismatch: " + input.size + " != " + inputCount.size + ".") |
| } |
| |
| val eu = recipe.getInt("eu") |
| val duration = recipe.getInt("time") |
| |
| (input, inputCount).zipped.foreach((stack, count) => if (stack != null && count > 0) stack.stackSize = stack.getMaxStackSize min count) |
| input.padTo(2, null) |
| |
| if (input(0) != null) { |
| GregTech.addAssemblerRecipe(input(0), input(1), output, duration, eu) |
| } |
| } |
| |
| private def addFurnaceRecipe(output: ItemStack, recipe: Config) { |
| val input = parseIngredient(recipe.getValue("input").unwrapped()) |
| output.stackSize = tryGetCount(recipe) |
| |
| input match { |
| case stack: ItemStack => |
| FurnaceRecipes.smelting.func_151394_a(stack, output, 0) |
| case name: String => |
| for (stack <- OreDictionary.getOres(name)) { |
| FurnaceRecipes.smelting.func_151394_a(stack, output, 0) |
| } |
| case _ => |
| } |
| } |
| |
| private def parseIngredient(entry: AnyRef) = entry match { |
| case map: java.util.Map[AnyRef, AnyRef]@unchecked => |
| if (map.contains("oreDict")) { |
| map.get("oreDict") match { |
| case value: String => value |
| case other => throw new RecipeException("Invalid name in recipe (not a string: " + other + ").") |
| } |
| } |
| else if (map.contains("item")) { |
| map.get("item") match { |
| case name: String => |
| // TODO Item.itemRegistry.getObject? |
| Item.itemRegistry.find { |
| case item: Item => itemNameEquals(item, name) |
| } match { |
| case Some(item: Item) => new ItemStack(item, 1, tryGetId(map)) |
| case _ => throw new RecipeException("No item found with name '" + name + "'.") |
| } |
| case id: Number => new ItemStack(validateItemId(id), 1, tryGetId(map)) |
| case other => throw new RecipeException("Invalid item name in recipe (not a string: " + other + ").") |
| } |
| } |
| else if (map.contains("block")) { |
| map.get("block") match { |
| case name: String => |
| // TODO Block.blockRegistry.getObject? |
| Block.blockRegistry.find { |
| case block: Block => blockNameEquals(block, name) |
| } match { |
| case Some(block: Block) => new ItemStack(block, 1, tryGetId(map)) |
| case _ => throw new RecipeException("No block found with name '" + name + "'.") |
| } |
| case id: Number => new ItemStack(validateBlockId(id), 1, tryGetId(map)) |
| case other => throw new RecipeException("Invalid block name (not a string: " + other + ").") |
| } |
| } |
| else throw new RecipeException("Invalid ingredient type (no oreDict, item or block entry).") |
| case name: String => |
| if (name == null || name.trim.isEmpty) null |
| else if (OreDictionary.getOres(name) != null && !OreDictionary.getOres(name).isEmpty) name |
| else { |
| // TODO Item.itemRegistry.getObject? |
| Item.itemRegistry.find { |
| case item: Item => itemNameEquals(item, name) |
| } match { |
| case Some(item: Item) => new ItemStack(item, 1, 0) |
| case _ => |
| // TODO Block.blockRegistry.getObject? |
| Block.blockRegistry.find { |
| case block: Block => blockNameEquals(block, name) |
| } match { |
| case Some(block: Block) => new ItemStack(block, 1, 0) |
| case _ => throw new RecipeException("No ore dictionary entry, item or block found for ingredient with name '" + name + "'.") |
| } |
| } |
| } |
| case other => throw new RecipeException("Invalid ingredient type (not a map or string): " + other) |
| } |
| |
| private def itemNameEquals(item: Item, name: String) = |
| item != null && (item.getUnlocalizedName == name || item.getUnlocalizedName == "item." + name) |
| |
| private def blockNameEquals(block: Block, name: String) = |
| block != null && (block.getUnlocalizedName == name || block.getUnlocalizedName == "tile." + name) |
| |
| private def tryGetType(recipe: Config) = if (recipe.hasPath("type")) recipe.getString("type") else "shaped" |
| |
| private def tryGetCount(recipe: Config) = if (recipe.hasPath("output")) recipe.getInt("output") else 1 |
| |
| private def tryGetId(ingredient: java.util.Map[AnyRef, AnyRef]): Int = |
| if (ingredient.contains("subID")) ingredient.get("subID") match { |
| case id: Number => id.intValue |
| case "any" => OreDictionary.WILDCARD_VALUE |
| case id: String => Integer.valueOf(id) |
| case _ => 0 |
| } else 0 |
| |
| private def validateBlockId(id: Number) = { |
| val index = id.intValue |
| val block = Block.getBlockById(index) |
| if (block == null) throw new RecipeException("Invalid block ID: " + index) |
| block |
| } |
| |
| private def validateItemId(id: Number) = { |
| val index = id.intValue |
| val item = Item.getItemById(index) |
| if (item == null) throw new RecipeException("Invalid item ID: " + index) |
| item |
| } |
| |
| private def hide(value: ItemStack) { |
| Items.multi.subItem(value) match { |
| case Some(stack) => stack.showInItemList = false |
| case _ => Delegator.subBlock(value) match { |
| case Some(block) => block.showInItemList = false |
| case _ => |
| } |
| } |
| } |
| |
| private class RecipeException(message: String) extends RuntimeException(message) |
| |
| } |