Split recipe loader to 2 phases, added statement to override recipes

This commit is contained in:
bdew committed 2013-12-23 17:44:38 +02:00
1 parent 914815fee7
commit 745cf43928
3 files changed
+88 -18

No files matched your search

+27 -8
View File
@@ -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
+58 -10
View File
@@ -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
@@ -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.*