diff --git a/src/net/bdew/lib/recipes/DataClasses.scala b/src/net/bdew/lib/recipes/DataClasses.scala index f863bb0..d19795c 100644 --- a/src/net/bdew/lib/recipes/DataClasses.scala +++ b/src/net/bdew/lib/recipes/DataClasses.scala @@ -89,6 +89,12 @@ case class StackMacro(id: Char) extends StackRef */ abstract class Statement +/** + * Base class for delayed statements (executed after everything is parsed) + * Actual processing is in [[net.bdew.lib.recipes.RecipeLoader.processDelayedStatements]] + */ +abstract class DelayedStatement extends Statement + /** * Character assignment * Syntax: {char} = {ref} @@ -96,7 +102,7 @@ abstract class Statement * @param char Character to assign * @param spec ItemStack Reference */ -case class StCharAssign(char: Char, spec: StackRef) extends Statement +case class StCharAssign(char: Char, spec: StackRef) extends DelayedStatement /** * Define class macro @@ -105,7 +111,7 @@ case class StCharAssign(char: Char, spec: StackRef) extends Statement * @param id Macro identifier * @param cls Class name */ -case class StClassMacro(id: String, cls: String) extends Statement +case class StClassMacro(id: String, cls: String) extends DelayedStatement /** * Conditional block - checks if mod is loaded @@ -127,6 +133,19 @@ case class StIfHaveMod(mod: String, thn: List[Statement], els: List[Statement]) */ case class StIfHaveOD(id: String, thn: List[Statement], els: List[Statement]) extends Statement +/** + * Removes previously defined recieps for a specific result + * @param res Recipes that produce this result will be cleared + */ +case class StClearRecipes(res: StackRef) extends Statement + +/** + * Base class for staments that represent a crafting recipe + */ +abstract class CraftingStatement extends DelayedStatement { + def result: StackRef +} + /** * Shaped recipe definition * @@ -147,10 +166,10 @@ case class StIfHaveOD(id: String, thn: List[Statement], els: List[Statement]) ex * Parser: [[net.bdew.lib.recipes.RecipeParser.recipeShaped9]] * * @param rec Recipe pattern - * @param res Result reference + * @param result Result reference * @param cnt Number of output items */ -case class StRecipeShaped(rec: Seq[String], res: StackRef, cnt: Int) extends Statement +case class StRecipeShaped(rec: Seq[String], result: StackRef, cnt: Int) extends CraftingStatement /** * Shapeless recipe definition @@ -158,10 +177,10 @@ case class StRecipeShaped(rec: Seq[String], res: StackRef, cnt: Int) extends Sta * Parser: [[net.bdew.lib.recipes.RecipeParser.recipeShapeless]] * * @param rec Recipe pattehrn - * @param res Result reference + * @param result Result reference * @param cnt Number of output items */ -case class StRecipeShapeless(rec: String, res: StackRef, cnt: Int) extends Statement +case class StRecipeShapeless(rec: String, result: StackRef, cnt: Int) extends CraftingStatement /** * Smelting recipe definition @@ -169,11 +188,11 @@ case class StRecipeShapeless(rec: String, res: StackRef, cnt: Int) extends State * Parser [[net.bdew.lib.recipes.RecipeParser.recipeSmelting]] * * @param in Input Stack - * @param out Output Stack + * @param result Output Stack * @param cnt Output Count * @param xp XP for smelting */ -case class StSmeltRecipe(in: StackRef, out: StackRef, cnt: Int, xp: Float) extends Statement +case class StSmeltRecipe(in: StackRef, result: StackRef, cnt: Int, xp: Float) extends CraftingStatement /** * Used in statement processing to abort the current statement and show an error without a stack trace diff --git a/src/net/bdew/lib/recipes/RecipeLoader.scala b/src/net/bdew/lib/recipes/RecipeLoader.scala index ba30d75..43d46c0 100644 --- a/src/net/bdew/lib/recipes/RecipeLoader.scala +++ b/src/net/bdew/lib/recipes/RecipeLoader.scala @@ -40,18 +40,23 @@ class RecipeLoader { /** * Current map of recipe characters to parser item references */ - val currCharMap = collection.mutable.Map.empty[Char, StackRef].withDefault(x => error("Undefined recipe character '%s'", x)) + var currCharMap = Map.empty[Char, StackRef].withDefault(x => error("Undefined recipe character '%s'", x)) /** * Current map of class macros */ - val currClassMacros = collection.mutable.Map.empty[String, String].withDefault(x => error("Undefined class macro '%s'", x)) + var currClassMacros = Map.empty[String, String].withDefault(x => error("Undefined class macro '%s'", x)) /** * Triggers an error with formatted string */ def error(msg: String, params: Any*) = throw new StatementError(msg.format(params: _*)) + /** + * List of unprocessed delayed statements + */ + var delayedStatements = List.empty[DelayedStatement] + /** * Looks up a recipe component * @param s Parser ItemStack reference @@ -209,14 +214,6 @@ class RecipeLoader { * @param s The statement */ def processStatement(s: Statement): Unit = s match { - case StCharAssign(c, r) => - currCharMap(c) = r - log.info("Added %s = %s".format(c, r)) - - case StClassMacro(id, cls) => - currClassMacros(id) = cls - log.info("Added def %s = %s".format(id, cls)) - case StIfHaveMod(mod, thn, els) => if (Misc.haveModVersion(mod)) { log.info("ifMod: %s found".format(mod)) @@ -235,6 +232,38 @@ class RecipeLoader { processStatementsSafe(els) } + case StClearRecipes(res) => + log.info("Clearing recipes that produce %s".format(res)) + delayedStatements = delayedStatements.filter({ + x => + if (x.isInstanceOf[CraftingStatement]) + if (x.asInstanceOf[CraftingStatement].result == res) { + log.info("Removing recipe %s".format(x)) + false + } else true + else true + }) + + case x: DelayedStatement => + delayedStatements :+= x + + case x => + log.severe("Can't process %s - this is a programing bug!".format(x)) + } + + /** + * Process a single delayed statement + * @param st The statement + */ + def processDelayedStatement(st: DelayedStatement) = st match { + case StCharAssign(c, r) => + currCharMap += (c -> r) + log.info("Added %s = %s".format(c, r)) + + case StClassMacro(id, cls) => + currClassMacros += (id -> cls) + log.info("Added def %s = %s".format(id, cls)) + case StRecipeShaped(rec, res, cnt) => log.info("Adding shaped recipe %s => %s * %d".format(rec, res, cnt)) val (comp, needOd) = resolveRecipeComponents(rec.mkString("")) @@ -291,6 +320,25 @@ class RecipeLoader { log.severe("Can't process %s - this is a programing bug!".format(x)) } + /** + * Process delayed statements, clear the list afterwards + */ + def processDelayedStatements() { + log.info("Processing %d delayed statements".format(delayedStatements.size)) + for (s <- delayedStatements) { + try { + processDelayedStatement(s) + } catch { + case e: StatementError => + log.severe("Error while processing %s: %s".format(s, e.getMessage)) + case e: Throwable => + log.severe("Error while processing %s: %s".format(s, e)) + e.printStackTrace() + } + } + delayedStatements = List.empty + } + /** * Process a list of statements and catch all exceptions * @param r The list to process diff --git a/src/net/bdew/lib/recipes/RecipeParser.scala b/src/net/bdew/lib/recipes/RecipeParser.scala index bd13ed6..492944c 100644 --- a/src/net/bdew/lib/recipes/RecipeParser.scala +++ b/src/net/bdew/lib/recipes/RecipeParser.scala @@ -102,6 +102,8 @@ class RecipeParser extends JavaTokenParsers { case in ~ (out ~ n) ~ xp => StSmeltRecipe(in, out, n.getOrElse(1), xp.getOrElse("0").toFloat) } + def clearRecipes = "clearRecipes" ~> ":" ~> spec ^^ { case sp => StClearRecipes(sp) } + def statement: Parser[Statement] = ( charSpec | classMacro @@ -111,6 +113,7 @@ class RecipeParser extends JavaTokenParsers { | recipeShaped9 | recipeShapeless | recipeSmelting + | clearRecipes ) def statements = statement.*