Implemented stochastic grammar. Work in progress.

src/dk/itu/mario/level/grammar/LevelGrammar.java

@@ -7,9 +7,9 @@ import java.util.Random;
 import java.util.Set;
 import java.util.TreeSet;
 
+import dk.itu.mario.level.LevelComponent;
 import dk.itu.mario.level.LevelComponent.TYPE;
 
-
 public class LevelGrammar {
 	private Variable start;
 	private Map<Variable, ProductionRule> ruleMap = new HashMap<Variable, ProductionRule>();
@@ -31,40 +31,43 @@ public class LevelGrammar {
 		ruleMap.put(rule.getLHS(), rule);
 	}
 
-	public String generateRandom(long randomSeed) {
-		System.out.println("Generating random level parameters using seed: "
-				+ randomSeed);
-		List<Variable> startRuleRHS = getRule(getStart()).getRHS();
-		StringBuilder sb = new StringBuilder();
-		for (Variable var : startRuleRHS) {
-			sb.append(var.toString());
-		}
-		return sb.toString();
-	}
-
-	public String generateRandom() {
-		System.out.println("Creating new random seed for LevelGrammar");
-		return generateRandom(new Random().nextLong());
-	}
-
-	//TODO: refactor to recursively add children to the current node based on production rule
 	public LevelParseTree generateRandomTree(long randomSeed, int width) {
 		System.out.println("Generating random level parameters using seed: "
 				+ randomSeed);
-		List<Variable> startRuleRHS = getRule(getStart()).getRHS();
-		
-		ParseNode rootNode = new ParseNode(TYPE.FLAT,1.0);
+		Variable startRuleLHS = getStart();
+
+		ParseNode rootNode = new ParseNode(startRuleLHS.getType(), 1.0);
+		generateRecursive(rootNode, getRule(startRuleLHS).getRHS(), 1.0);
 		LevelParseTree parseTree = new LevelParseTree(rootNode, 0, width);
-		
-		for (Variable var : startRuleRHS) {
-			if (var.isTerminal()) {
-				rootNode.addChild(new ParseNode(TYPE.FLAT,0.5));
-			}
-		}
-		
+
 		return parseTree;
 	}
-	
+
+	private ParseNode generateRecursive(ParseNode parseNode, Clause clause,
+			double relativeWidth) {
+		if (clause.isVariable()) {
+			if (clause.isTerminal()) {
+				parseNode.addChild(new ParseNode(((Variable) clause).getType(),
+						relativeWidth));
+			} else {
+				generateRecursive(parseNode, getRule((Variable) clause)
+						.getRHS(), relativeWidth);
+			}
+		} else {
+			if (clause.isChoice()) {
+				generateRecursive(parseNode, clause.makeRandomChoice(),
+						relativeWidth);
+			} else {
+				int numSubClauses = clause.getNumSubClauses();
+				for (int i = 0; i < numSubClauses; i++) {
+					generateRecursive(parseNode, clause.getSubClause(i),
+							relativeWidth / numSubClauses);
+				}
+			}
+		}
+		return parseNode;
+	}
+
 	public ProductionRule getRule(Variable var) {
 		return ruleMap.get(var);
 	}