This patch has a TON of changes. I updated almost every challenge and added some new ones. I think it represents a good suite of possibilities. Check it out.

2012-03-18 05:25:33 -04:00
parent ac968b5b7f
commit f0b7487476
2 changed files with 716 additions and 317 deletions
--- a/src/dk/itu/mario/level/PCGLevel.java
+++ b/src/dk/itu/mario/level/PCGLevel.java
@@ -7,7 +7,6 @@ import java.util.Random;
 import dk.itu.mario.MarioInterface.GamePlay;
 import dk.itu.mario.MarioInterface.LevelInterface;
 import dk.itu.mario.engine.DataRecorder;
-import dk.itu.mario.engine.sprites.Enemy;
 import dk.itu.mario.engine.sprites.SpriteTemplate;
 import dk.itu.mario.level.grammar.LevelGrammar;
 import dk.itu.mario.level.grammar.LevelGrammarFactory;
@@ -16,6 +15,12 @@ import dk.itu.mario.level.matcher.ArchetypeMatcher;
 import dk.itu.mario.level.matcher.ProfileMatcher;

 public class PCGLevel extends Level {
+	public static double POWERUP_PROBABILITY = .1;
+	public static double BLOCKS_PROBABILITY = .3;
+	public static double COINS_PROBABILITY = .5;
+	public static int COIN_REWARD = 1;
+	public static int POWERUP_REWARD = 2;
+
 	public static boolean TESTING = true;
 	public static long lastSeed;
 	private static Random levelSeedRandom = new Random();
@@ -121,30 +126,50 @@ public class PCGLevel extends Level {
 		int length = 0;

 		if (TESTING) {
-			difficulty = 6;
+			difficulty = 10;
+			int minElements = 5;
+			int maxLen;
+			int elementsSoFar = 0;

-			length = buildStraight(0, width - 64, true);
-			length += buildFreebie(length, width - 64 - length);
+			length = buildStraight(0, width - 64, false);

-			length += buildBowlingAlley(length, width - 64 - length,
-					SpriteTemplate.ARMORED_TURTLE);
-			length += buildFreebie(length, width - 64 - length);
-
-			length += buildLemmingTrap(length, width - 64 - length);
-			length += buildFreebie(length, width - 64 - length);
-
-			length += buildPlatformJump(length, width - 64 - length);
-			length += buildFreebie(length, width - 64 - length);
-
-			length += buildMaze(length, width - 64 - length);
-			length += buildFreebie(length, width - 64 - length);
-
-			length += buildPipeJump(length, width - 64 - length);
-			length += buildFreebie(length, width - 64 - length);
-
-			// create all of the medium sections
 			while (length < width - 64) {
-				length += buildStraight(length, width - length, true);
+				maxLen = elementsSoFar < minElements ? (width - 64 - length)
+						/ (minElements - elementsSoFar) : width - 64 - length;
+
+				switch (random.nextInt(9)) {
+				case 0:
+					length += buildStraight(length, maxLen, true);
+					break;
+				case 1:
+					length += buildFreebie(length, maxLen);
+					break;
+				case 2:
+					length += buildBowlingAlley(length, maxLen);
+					break;
+				case 3:
+					length += buildLemmingTrap(length, maxLen);
+					break;
+				case 4:
+					length += buildPipeJump(length, maxLen);
+					break;
+				case 5:
+					length += buildPlatformJump(length, maxLen);
+					break;
+				case 6:
+					length += buildCoinDive(length, maxLen);
+					break;
+				case 7:
+					length += buildCannonLine(length, maxLen);
+					break;
+				case 8:
+					length += buildSinglePit(length, maxLen);
+					break;
+				default:
+					length += buildMaze(length, maxLen);
+				}
+
+				elementsSoFar++;
 			}
 		}

@@ -158,7 +183,8 @@ public class PCGLevel extends Level {
 				System.out.println("Building for: " + lcomp);
 				switch (lctype) {
 				case FLAT:
-					length += buildStraight(length, lcomp.getEnd(), true);
+					length += buildStraight(length, lcomp.getEnd(),
+							random.nextBoolean());
 					break;
 				case PIPE_JUMP:
 					length += buildPipeJump(length, width - 64 - length);
@@ -196,11 +222,100 @@ public class PCGLevel extends Level {
 		fillEndPiece(length, floor);
 	}

-	private int buildFreebie(int xo, int maxLength) {
-		if (maxLength >= 5) {
+	private int buildSinglePit(int xo, int maxLength) {
+		if (maxLength >= 13) {
+			int length = 13;
+			int floor = height - 1 - random.nextInt(4);
+
+			for (int x = 0; x < length; x++) {
+				if (x != 5 && x != 6 && x != 7) {
+					for (int y = floor; y < height; y++) {
+						setBlock(xo + x, y, Level.GROUND);
+					}
+				}
+
+				if ((x >= 2 && x <= 4) || (x >= 8 && x <= 10)) {
+					setBlock(xo + x, floor - 1, Level.ROCK);
+
+					if (x == 3 || x == 4 || x == 8 || x == 9) {
+						setBlock(xo + x, floor - 2, Level.ROCK);
+					}
+
+					if (x == 4 || x == 8) {
+						setBlock(xo + x, floor - 3, Level.ROCK);
+					}
+				}
+			}
+
+			return length;
+		}
+
+		return 0;
+	}
+
+	private int buildCannonLine(int xo, int maxLength) {
+		if (maxLength >= 6) {

 			int floor = height - 1 - random.nextInt(4);
-			for (int x = 0; x < 5; x++) {
+			int length = 6;
+
+			for (int x = 0; x < length; x++) {
+				for (int y = floor; y < height; y++) {
+					setBlock(xo + x, y, Level.GROUND);
+				}
+
+				if (x == 3) {
+					setBlock(xo + x, floor - 1, Level.CANNON_MIDDLE);
+					setBlock(xo + x, floor - 2, Level.CANNON_TOP);
+					setBlock(xo + x, floor - 3,
+							shouldAddChallenge() ? Level.CANNON_TOP
+									: Level.CANNON_MIDDLE);
+					setBlock(xo + x, floor - 4, Level.CANNON_TOP);
+				}
+			}
+
+			return length;
+		}
+		return 0;
+	}
+
+	private int buildCoinDive(int xo, int maxLength) {
+		if (maxLength >= 18) {
+			int length = 18;
+
+			int floor = height - 1 - random.nextInt(4);
+
+			for (int x = 0; x < length; x++) {
+				for (int y = floor; y < height; y++) {
+					setBlock(xo + x, y, Level.GROUND);
+				}
+
+				if (x > 2 && x < 6) {
+					setBlock(xo + x, floor - 3, Level.BLOCK_EMPTY);
+				} else if (x > 2 && x < 11) {
+					setBlock(xo + x, floor - 5, Level.BLOCK_EMPTY);
+				} else if (x == 11 || x == 12) {
+					setBlock(xo + x, floor - 6, Level.COIN);
+				} else if (x == 13) {
+					setBlock(xo + x, floor - 5, Level.COIN);
+				} else if (x == 14) {
+					setBlock(xo + x, floor - 4, Level.COIN);
+				} else if (x == 15) {
+					setBlock(xo + x, floor - 3, Level.COIN);
+				}
+			}
+
+			return length;
+		}
+
+		return 0;
+
+	}
+
+	private int buildFreebie(int xo, int maxLength) {
+		if (maxLength >= 9) {
+			int floor = height - 1 - random.nextInt(4);
+			for (int x = 0; x < 9; x++) {
 				for (int y = 0; y < height; y++) {
 					if (y >= floor) {
 						setBlock(xo + x, y, GROUND);
@@ -208,6 +323,46 @@ public class PCGLevel extends Level {
 				}
 			}

+			if (random.nextBoolean()) {
+				setBlock(xo + 1, floor - 1, Level.BLOCK_EMPTY);
+				setBlock(xo + 7, floor - 1, Level.BLOCK_POWERUP);
+
+				setSpriteTemplate(xo + 6, floor - 1, new SpriteTemplate(
+						SpriteTemplate.GREEN_TURTLE, false));
+			}
+
+			else {
+				int powerupLoc = random.nextInt(5);
+
+				setBlock(xo + 2, floor - 3,
+						powerupLoc == 0 ? Level.BLOCK_POWERUP
+								: Level.BLOCK_COIN);
+				setBlock(xo + 3, floor - 3,
+						powerupLoc == 1 ? Level.BLOCK_POWERUP
+								: Level.BLOCK_COIN);
+				setBlock(xo + 4, floor - 3,
+						powerupLoc == 2 ? Level.BLOCK_POWERUP
+								: Level.BLOCK_COIN);
+				setBlock(xo + 5, floor - 3,
+						powerupLoc == 3 ? Level.BLOCK_POWERUP
+								: Level.BLOCK_COIN);
+				setBlock(xo + 6, floor - 3,
+						powerupLoc == 4 ? Level.BLOCK_POWERUP
+								: Level.BLOCK_COIN);
+			}
+
+			return 9;
+		}
+
+		else if (maxLength >= 5) {
+
+			int floor = height - 1 - random.nextInt(4);
+			for (int x = 0; x < 5; x++) {
+				for (int y = floor; y < height; y++) {
+					setBlock(xo + x, y, GROUND);
+				}
+			}
+
 			if (random.nextBoolean()) {
 				setBlock(xo, floor - 1, Level.BLOCK_EMPTY);
 				setBlock(xo + 4, floor - 1, Level.BLOCK_POWERUP);
@@ -225,37 +380,85 @@ public class PCGLevel extends Level {
 		return 0;
 	}

-	private int buildBowlingAlley(int xo, int maxLength, int enemyType) {
-		if (maxLength >= 26
-				&& (enemyType == SpriteTemplate.ARMORED_TURTLE || enemyType == SpriteTemplate.GREEN_TURTLE)) {
+	private int buildBowlingAlley(int xo, int maxLength) {
+		if (maxLength >= 26) {

+			int floor = height - 1 - random.nextInt(4);
+			int enemyType = shouldAddChallenge() ? (shouldAddChallenge() ? SpriteTemplate.ARMORED_TURTLE
+					: SpriteTemplate.GREEN_TURTLE)
+					: SpriteTemplate.GOOMPA;
+			int reward = shouldAddReward();
+			boolean arc = random.nextBoolean();
 			int numEnemies = 0;
 			for (int i = 0; i < 10; i++) {
 				numEnemies += shouldAddChallenge() ? 1 : 0;
 			}

 			// Create the pit.
-			setBlock(xo, this.height - 2, Level.GROUND);
-			setBlock(xo, this.height - 1, Level.GROUND);
+			for (int y = floor - 1; y < height; y++) {
+				setBlock(xo, y, Level.GROUND);
+				setBlock(xo + 1, y, Level.GROUND);
+			}

-			setBlock(xo + 1, this.height - 1, Level.GROUND);
-			setBlock(xo + 1, this.height - 2, Level.GROUND);
+			for (int y = floor; y < height; y++) {
+				setBlock(xo + 2, y, Level.GROUND);
+				setBlock(xo + 3, y, Level.GROUND);
+				setBlock(xo + 4, y, Level.GROUND);
+			}

-			setBlock(xo + 2, this.height - 1, Level.GROUND);
-			setBlock(xo + 3, this.height - 1, Level.GROUND);
-			setBlock(xo + 4, this.height - 1, Level.GROUND);
-
-			setSpriteTemplate(xo + 2, this.height - 2, new SpriteTemplate(
+			setSpriteTemplate(xo + 2, floor - 1, new SpriteTemplate(
 					SpriteTemplate.RED_TURTLE, false));

 			for (int x = 5; x < 26; x++) {
-				setBlock(xo + x, this.height - 1, Level.GROUND);
-				setBlock(xo + x, this.height - 2, Level.GROUND);
-				setBlock(xo + x, this.height - 3, Level.GROUND);
+				for (int y = floor - 3; y < height; y++) {
+					setBlock(xo + x, y, Level.GROUND);
+				}
+
+				if (arc && reward == 1 && x >= 11 && x <= 23) {
+					if (x == 15) {
+						setBlock(xo + x, floor - 6, Level.COIN);
+					}
+
+					else if (x == 16) {
+						setBlock(xo + x, floor - 7, Level.COIN);
+					}
+
+					else if (x == 18) {
+						setBlock(xo + x, floor - 8, Level.COIN);
+					}
+
+					else if (x == 19) {
+						setBlock(xo + x, floor - 8, Level.COIN);
+					}
+
+					else if (x == 20) {
+						setBlock(xo + x, floor - 8, Level.COIN);
+					}
+
+					else if (x == 22) {
+						setBlock(xo + x, floor - 7, Level.COIN);
+					}
+
+					else if (x == 23) {
+						setBlock(xo + x, floor - 6, Level.COIN);
+					}
+				}
+
+				else if (!arc && reward == 1 && x >= 10 && x <= 20) {
+					setBlock(xo + x, floor - 6, Level.COIN);
+				}
+
+				else if (reward == 2 && x >= 13 && x <= 17) {
+					setBlock(
+							xo + x,
+							floor - 6,
+							(random.nextDouble() <= POWERUP_PROBABILITY) ? Level.BLOCK_POWERUP
+									: Level.BLOCK_COIN);
+				}

 				if (x >= 26 - numEnemies) {
-					setSpriteTemplate(xo + x, this.height - 4,
-							new SpriteTemplate(enemyType, false));
+					setSpriteTemplate(xo + x, floor - 4, new SpriteTemplate(
+							enemyType, false));
 				}
 			}

@@ -267,25 +470,42 @@ public class PCGLevel extends Level {

 	private int buildLemmingTrap(int xo, int maxLength) {
 		if (maxLength >= 14) {
+			int floor = height - 1 - random.nextInt(4);
 			int enemyType = shouldAddChallenge() ? (shouldAddChallenge() ? SpriteTemplate.ARMORED_TURTLE
 					: SpriteTemplate.GREEN_TURTLE)
 					: SpriteTemplate.GOOMPA;
 			boolean flying = shouldAddChallenge() && shouldAddChallenge()
 					&& shouldAddChallenge();
+			int reward = shouldAddReward();

 			for (int x = 0; x < 18; x++) {
 				if (x > 5) {
-					for (int y = 0; y < 5; y++) {
-						setBlock(xo + x, this.height - 1 - y, Level.GROUND);
+					for (int y = floor - 4; y < height; y++) {
+						setBlock(xo + x, y, Level.GROUND);
+					}
+				}
+
+				else {
+					for (int y = floor; y < height; y++) {
+						setBlock(xo + x, y, Level.GROUND);
 					}
-				} else {
-					setBlock(xo + x, this.height - 1 - ((x > 5) ? 6 : 0),
-							Level.GROUND);
 				}

 				if (x > 6 && x % 2 == 0) {
-					setSpriteTemplate(xo + x, this.height - 6,
-							new SpriteTemplate(enemyType, flying));
+					setSpriteTemplate(xo + x, floor - 5, new SpriteTemplate(
+							enemyType, flying));
+				}
+
+				if (reward == 1 && x >= 7 && x <= 16) {
+					setBlock(xo + x, floor - 7, Level.COIN);
+				}
+
+				else if (reward == 2 && x >= 10 && x <= 13) {
+					setBlock(
+							xo + x,
+							floor - 7,
+							random.nextDouble() < POWERUP_PROBABILITY ? Level.BLOCK_POWERUP
+									: Level.BLOCK_COIN);
 				}
 			}
 			return 18;
@@ -324,25 +544,6 @@ public class PCGLevel extends Level {
 		fixWalls();
 	}

-	private void addEnemyLine(int x0, int x1, int y) {
-		for (int x = x0; x < x1; x++) {
-			if (random.nextInt(35) < difficulty + 1) {
-				int type = random.nextInt(4);
-
-				if (difficulty < 1) {
-					type = Enemy.ENEMY_GOOMBA;
-				} else if (difficulty < 3) {
-					type = random.nextInt(3);
-				}
-
-				setSpriteTemplate(x, y,
-						new SpriteTemplate(type,
-								random.nextInt(35) < difficulty));
-				ENEMIES++;
-			}
-		}
-	}
-
 	private void blockify(Level level, boolean[][] blocks, int width, int height) {
 		int to = 0;
 		if (type == LevelInterface.TYPE_CASTLE) {
@@ -442,6 +643,19 @@ public class PCGLevel extends Level {
 		return random.nextInt(11) + 1 <= difficulty;
 	}

+	private int shouldAddReward() {
+		double guess = random.nextDouble();
+
+		if (guess < COINS_PROBABILITY) {
+			return 1;
+		} else if (guess < COINS_PROBABILITY + BLOCKS_PROBABILITY) {
+			return 2;
+		} else {
+			return 0;
+		}
+
+	}
+
 	private int buildMaze(int xo, int maxLength) {
 		if (maxLength >= 19) {

@@ -515,9 +729,11 @@ public class PCGLevel extends Level {
 					// skipDown = (skipDown && (x == str.len - 2))
 					// || (str.len >= 5 && x == (str.len / 2));
 					midLine = (str.len >= 5 && x == (str.len / 2) - 1);
-					addEnemy = (str.len >= 5 && x == (str.len / 2));
 					stretchEnd = (x == str.len - 1);

+					addEnemy = !midLine && !stretchEnd
+							&& (random.nextDouble() < .25);
+
 					if // ((stretchEnd && nxt != null && nxt.lvl !=
 						// MazeLevel.BOT)
 						// ||
@@ -564,11 +780,11 @@ public class PCGLevel extends Level {
 								: SpriteTemplate.GREEN_TURTLE)
 								: SpriteTemplate.GOOMPA;

-						switch (str.lvl) {
-						case TOP:
+						switch (random.nextInt(3)) {
+						case 0:
 							heightMod = 8;
 							break;
-						case MID:
+						case 1:
 							heightMod = 5;
 							break;
 						default:
@@ -577,7 +793,7 @@ public class PCGLevel extends Level {

 						setSpriteTemplate(xo + soFar + x, this.height
 								- heightMod, new SpriteTemplate(enemyType,
-								shouldAddChallenge()));
+								false));
 					}
 				}

@@ -594,65 +810,81 @@ public class PCGLevel extends Level {
 	}

 	private int buildPipeJump(int xo, int maxLength) {
-		int numPipes = 4;
-		int length = numPipes * 2;
+		int length = 0;
 		int lastHeight = 4;
 		int localHeight;
+		int midFloor;
 		int pipeHeight;
 		int gap = 0;
+		boolean space;
+		boolean deadGaps = shouldAddChallenge();

-		while (length > maxLength) {
-			numPipes--;
-			length = numPipes * 2;
+		int numPipes;
+		for (numPipes = 0; shouldAddChallenge(); numPipes++) {
 		}

-		if (length == 0) {
-			return length;
-		}
+		localHeight = random.nextInt(2) + 1;
+		loop: for (int i = 0; i < numPipes; i++) {
+			space = (length + 2) <= maxLength;

-		for (int i = 0; i < numPipes && length < maxLength; i++) {
-			length += random.nextInt(4);
-		}
+			if (space) {
+				while (Math.abs(localHeight - lastHeight) > 3) {
+					localHeight += localHeight > lastHeight ? -1 : 1;
+				}

-		if (length > maxLength) {
-			length = maxLength;
-		}
+				lastHeight = localHeight;

-		for (int soFar = 0; numPipes > 0; numPipes--) {
-			localHeight = (soFar == 0) ? random.nextInt(2) + 4 : random
-					.nextInt(7) + 4;
+				pipeHeight = localHeight > 5 ? 4 + random
+						.nextInt(localHeight - 4) : 4;

-			while (Math.abs(localHeight - lastHeight) > 3) {
-				localHeight += localHeight > lastHeight ? -1 : 1;
-			}
+				for (int y = 0; y < localHeight; y++) {
+					setBlock(xo + length, this.height - 1 - y, Level.GROUND);
+					setBlock(xo + length + 1, this.height - 1 - y, Level.GROUND);

-			lastHeight = localHeight;
-			pipeHeight = localHeight > 5 ? 4 + random.nextInt(localHeight - 4)
-					: 4;
+					if (y == localHeight - 1) {
+						setBlock(xo + length, this.height - 1 - y,
+								Level.TUBE_TOP_LEFT);
+						setBlock(xo + length + 1, this.height - 1 - y,
+								Level.TUBE_TOP_RIGHT);

-			for (int y = 0; y < localHeight; y++) {
-				setBlock(xo + soFar, this.height - 1 - y, Level.GROUND);
-				setBlock(xo + soFar + 1, this.height - 1 - y, Level.GROUND);
+						if (shouldAddChallenge()) {
+							setSpriteTemplate(xo + length, this.height - y,
+									new SpriteTemplate(
+											SpriteTemplate.JUMP_FLOWER, false));
+						}
+					} else if (y > localHeight - pipeHeight) {
+						setBlock(xo + length, this.height - 1 - y,
+								Level.TUBE_SIDE_LEFT);
+						setBlock(xo + length + 1, this.height - 1 - y,
+								Level.TUBE_SIDE_RIGHT);
+					}
+				}

-				if (y == localHeight - 1) {
-					setBlock(xo + soFar, this.height - 1 - y,
-							Level.TUBE_TOP_LEFT);
-					setBlock(xo + soFar + 1, this.height - 1 - y,
-							Level.TUBE_TOP_RIGHT);
-				} else if (y > localHeight - pipeHeight) {
-					setBlock(xo + soFar, this.height - 1 - y,
-							Level.TUBE_SIDE_LEFT);
-					setBlock(xo + soFar + 1, this.height - 1 - y,
-							Level.TUBE_SIDE_RIGHT);
+				length += 2;
+
+				localHeight = random.nextInt(7) + 4;
+
+				midFloor = localHeight - (random.nextInt(4) + 1);
+				if (midFloor <= 0) {
+					midFloor = 1;
+				}
+
+				for (gap = 0; gap < 4 && length + gap <= maxLength
+						&& shouldAddChallenge(); gap++) {
+
+					if (!deadGaps) {
+						for (int y = 0; y < midFloor; y++) {
+							setBlock(xo + length, this.height - 1 - y,
+									Level.GROUND);
+						}
+					}
+					length++;
 				}
 			}

-			gap = random.nextInt(4);
-			while (soFar + gap + 2 > length && gap >= 0) {
-				gap--;
+			else {
+				break loop;
 			}
-
-			soFar += (2 + gap);
 		}

 		return length;
@@ -665,7 +897,13 @@ public class PCGLevel extends Level {
 		for (gapLength = 1; shouldAddChallenge() && gapLength < 4; gapLength++) {
 		}

-		int numPlatforms = random.nextInt((maxLength - 3) / (4 + gapLength));
+		int maxNumPlatforms = (maxLength - 3) / (4 + gapLength);
+
+		if (maxNumPlatforms == 0) {
+			return 0;
+		}
+
+		int numPlatforms = random.nextInt(maxNumPlatforms);

 		if (numPlatforms > 1) {
 			boolean found = false;
@@ -676,6 +914,8 @@ public class PCGLevel extends Level {
 			int heightMod = 0;
 			int lastHeightMod = 0;
 			int enemyType;
+			int reward;
+			LevelComponent.PlatformLevel hold;

 			jumps.add(LevelComponent.PlatformLevel.BOT);

@@ -738,7 +978,8 @@ public class PCGLevel extends Level {
 					lastHeightMod = heightMod;
 				}

-				switch (jumps.get(x)) {
+				hold = jumps.get(x);
+				switch (hold) {
 				case TOP:
 					heightMod = 12;
 					break;
@@ -766,10 +1007,10 @@ public class PCGLevel extends Level {

 				if (shouldAddChallenge()) {

-					enemyType = shouldAddChallenge() ? (shouldAddChallenge() ? (shouldAddChallenge() ? SpriteTemplate.ARMORED_TURTLE
-							: SpriteTemplate.RED_TURTLE)
-							: SpriteTemplate.GREEN_TURTLE)
-							: SpriteTemplate.GOOMPA;
+					enemyType = random.nextBoolean() ? SpriteTemplate.RED_TURTLE
+							: (shouldAddChallenge() ? (shouldAddChallenge() ? SpriteTemplate.ARMORED_TURTLE
+									: SpriteTemplate.GREEN_TURTLE)
+									: SpriteTemplate.GOOMPA);

 					setSpriteTemplate(
 							xo + length + 3,
@@ -780,6 +1021,33 @@ public class PCGLevel extends Level {
 											|| enemyType != SpriteTemplate.RED_TURTLE));
 				}

+				reward = shouldAddReward();
+				if (reward == COIN_REWARD
+						&& hold != LevelComponent.PlatformLevel.TOP) {
+					setBlock(xo + length, this.height - heightMod - 3,
+							Level.COIN);
+					setBlock(xo + length + 1, this.height - heightMod - 3,
+							Level.COIN);
+					setBlock(xo + length + 2, this.height - heightMod - 3,
+							Level.COIN);
+					setBlock(xo + length + 3, this.height - heightMod - 3,
+							Level.COIN);
+				}
+
+				else if (reward == POWERUP_REWARD
+						&& hold != LevelComponent.PlatformLevel.TOP) {
+					setBlock(
+							xo + length + 1,
+							this.height - heightMod - 3,
+							random.nextDouble() < POWERUP_PROBABILITY ? Level.BLOCK_POWERUP
+									: Level.BLOCK_COIN);
+					setBlock(
+							xo + length + 2,
+							this.height - heightMod - 3,
+							random.nextDouble() < POWERUP_PROBABILITY ? Level.BLOCK_POWERUP
+									: Level.BLOCK_COIN);
+				}
+
 				length += 4 + gapLength;
 			}
 		}
@@ -787,16 +1055,17 @@ public class PCGLevel extends Level {
 		return length;
 	}

-	private int buildStraight(int xo, int maxLength, boolean safe) {
-		int length = random.nextInt(10) + 2;
+	private int buildStraight(int xo, int maxLength, boolean allowEnemies) {
+		int length = random.nextInt(15) + 2;

-		if (safe)
-			length = 10 + random.nextInt(5);
+		// if (safe)
+		// length = 10 + random.nextInt(5);

 		if (length > maxLength)
 			length = maxLength;

 		int floor = height - 1 - random.nextInt(4);
+		int reward = shouldAddReward();

 		// runs from the specified x position to the length of the segment
 		for (int x = xo; x < xo + length; x++) {
@@ -807,70 +1076,181 @@ public class PCGLevel extends Level {
 			}
 		}

-		if (!safe) {
-			if (length > 5) {
-				decorate(xo, xo + length, floor);
+		if (shouldAddChallenge() && allowEnemies) {
+			int enemyType = shouldAddChallenge() ? (shouldAddChallenge() ? (shouldAddChallenge() ? (shouldAddChallenge()
+					|| (reward > 0 && length >= 5) ? SpriteTemplate.ARMORED_TURTLE
+					: SpriteTemplate.CANNON_BALL)
+					: SpriteTemplate.RED_TURTLE)
+					: SpriteTemplate.GREEN_TURTLE)
+					: SpriteTemplate.GOOMPA;
+
+			if (enemyType == SpriteTemplate.CANNON_BALL) {
+				int height = random.nextInt(4) + 1;
+
+				if (height == 1) {
+					setBlock(xo + (length / 2), floor - 1, Level.CANNON_TOP);
+				}
+
+				else if (height == 2) {
+					setBlock(xo + (length / 2), floor - 1, Level.CANNON_MIDDLE);
+					setBlock(xo + (length / 2), floor - 2, Level.CANNON_TOP);
+				}
+
+				else if (height == 3) {
+					setBlock(xo + (length / 2), floor - 1, Level.CANNON_BOTTOM);
+					setBlock(xo + (length / 2), floor - 2, Level.CANNON_MIDDLE);
+					setBlock(xo + (length / 2), floor - 3, Level.CANNON_TOP);
+				}
+
+				else {
+					setBlock(xo + (length / 2), floor - 1, Level.CANNON_BOTTOM);
+					setBlock(xo + (length / 2), floor - 2, Level.CANNON_BOTTOM);
+					setBlock(xo + (length / 2), floor - 3, Level.CANNON_MIDDLE);
+					setBlock(xo + (length / 2), floor - 4, Level.CANNON_TOP);
+				}
+			}
+
+			else {
+				setSpriteTemplate(xo + (length / 2), floor - 1,
+						new SpriteTemplate(enemyType, shouldAddChallenge()));
 			}
 		}

+		if (reward > 0) {
+			if (length >= 13) {
+				setBlock(xo + (length - 11), floor - 3, Level.COIN);
+				setBlock(xo + (length - 10), floor - 4, Level.COIN);
+				setBlock(xo + (length - 8), floor - 5, Level.COIN);
+				setBlock(xo + (length - 7), floor - 5, Level.COIN);
+				setBlock(xo + (length - 6), floor - 5, Level.COIN);
+				setBlock(xo + (length - 4), floor - 4, Level.COIN);
+				setBlock(xo + (length - 3), floor - 3, Level.COIN);
+			}
+
+			else if (length >= 7) {
+				int start = length / 2;
+				boolean coins = (reward == 1);
+
+				setBlock(
+						xo + (start - 2),
+						floor - 3,
+						coins ? Level.COIN
+								: random.nextDouble() < POWERUP_PROBABILITY ? Level.BLOCK_POWERUP
+										: Level.BLOCK_COIN);
+				setBlock(
+						xo + (start - 1),
+						floor - 3,
+						coins ? Level.COIN
+								: random.nextDouble() < POWERUP_PROBABILITY ? Level.BLOCK_POWERUP
+										: Level.BLOCK_COIN);
+				setBlock(
+						xo + start,
+						floor - 3,
+						coins ? Level.COIN
+								: random.nextDouble() < POWERUP_PROBABILITY ? Level.BLOCK_POWERUP
+										: Level.BLOCK_COIN);
+				setBlock(
+						xo + (start + 2),
+						floor - 3,
+						coins ? Level.COIN
+								: random.nextDouble() < POWERUP_PROBABILITY ? Level.BLOCK_POWERUP
+										: Level.BLOCK_COIN);
+				setBlock(
+						xo + (start + 1),
+						floor - 3,
+						coins ? Level.COIN
+								: random.nextDouble() < POWERUP_PROBABILITY ? Level.BLOCK_POWERUP
+										: Level.BLOCK_COIN);
+			}
+
+			else if (length >= 5) {
+				int start = length / 2;
+				boolean coins = (reward == 1);
+
+				setBlock(
+						xo + (start - 1),
+						floor - 3,
+						coins ? Level.COIN
+								: random.nextDouble() < POWERUP_PROBABILITY ? Level.BLOCK_POWERUP
+										: Level.BLOCK_COIN);
+				setBlock(
+						xo + start,
+						floor - 3,
+						coins ? Level.COIN
+								: random.nextDouble() < POWERUP_PROBABILITY ? Level.BLOCK_POWERUP
+										: Level.BLOCK_COIN);
+				setBlock(
+						xo + (start + 1),
+						floor - 3,
+						coins ? Level.COIN
+								: random.nextDouble() < POWERUP_PROBABILITY ? Level.BLOCK_POWERUP
+										: Level.BLOCK_COIN);
+			}
+		}
+		// if (!safe) {
+		// if (length > 5) {
+		// decorate(xo, xo + length, floor);
+		// }
+		// }
+
 		return length;
 	}

-	private void decorate(int xStart, int xLength, int floor) {
-		// if its at the very top, just return
-		if (floor < 1)
-			return;
-
-		// boolean coins = random.nextInt(3) == 0;
-		boolean rocks = true;
-
-		// add an enemy line above the box
-		addEnemyLine(xStart + 1, xLength - 1, floor - 1);
-
-		int s = random.nextInt(4);
-		int e = random.nextInt(4);
-
-		if (floor - 2 > 0) {
-			if ((xLength - 1 - e) - (xStart + 1 + s) > 1) {
-				for (int x = xStart + 1 + s; x < xLength - 1 - e; x++) {
-					setBlock(x, floor - 2, COIN);
-					COINS++;
-				}
-			}
-		}
-
-		s = random.nextInt(4);
-		e = random.nextInt(4);
-
-		// this fills the set of blocks and the hidden objects inside them
-		if (floor - 4 > 0) {
-			if ((xLength - 1 - e) - (xStart + 1 + s) > 2) {
-				for (int x = xStart + 1 + s; x < xLength - 1 - e; x++) {
-					if (rocks) {
-						if (x != xStart + 1 && x != xLength - 2
-								&& random.nextInt(3) == 0) {
-							if (random.nextInt(4) == 0) {
-								setBlock(x, floor - 4, BLOCK_POWERUP);
-								BLOCKS_POWER++;
-							} else { // the fills a block with a hidden coin
-								setBlock(x, floor - 4, BLOCK_COIN);
-								BLOCKS_COINS++;
-							}
-						} else if (random.nextInt(4) == 0) {
-							if (random.nextInt(4) == 0) {
-								setBlock(x, floor - 4, (byte) (2 + 1 * 16));
-							} else {
-								setBlock(x, floor - 4, (byte) (1 + 1 * 16));
-							}
-						} else {
-							setBlock(x, floor - 4, BLOCK_EMPTY);
-							BLOCKS_EMPTY++;
-						}
-					}
-				}
-			}
-		}
-	}
+	// private void decorate(int xStart, int xLength, int floor) {
+	// // if its at the very top, just return
+	// if (floor < 1)
+	// return;
+	//
+	// // boolean coins = random.nextInt(3) == 0;
+	// boolean rocks = true;
+	//
+	// // add an enemy line above the box
+	// addEnemyLine(xStart + 1, xLength - 1, floor - 1);
+	//
+	// int s = random.nextInt(4);
+	// int e = random.nextInt(4);
+	//
+	// if (floor - 2 > 0) {
+	// if ((xLength - 1 - e) - (xStart + 1 + s) > 1) {
+	// for (int x = xStart + 1 + s; x < xLength - 1 - e; x++) {
+	// setBlock(x, floor - 2, COIN);
+	// COINS++;
+	// }
+	// }
+	// }
+	//
+	// s = random.nextInt(4);
+	// e = random.nextInt(4);
+	//
+	// // this fills the set of blocks and the hidden objects inside them
+	// if (floor - 4 > 0) {
+	// if ((xLength - 1 - e) - (xStart + 1 + s) > 2) {
+	// for (int x = xStart + 1 + s; x < xLength - 1 - e; x++) {
+	// if (rocks) {
+	// if (x != xStart + 1 && x != xLength - 2
+	// && random.nextInt(3) == 0) {
+	// if (random.nextInt(4) == 0) {
+	// setBlock(x, floor - 4, BLOCK_POWERUP);
+	// BLOCKS_POWER++;
+	// } else { // the fills a block with a hidden coin
+	// setBlock(x, floor - 4, BLOCK_COIN);
+	// BLOCKS_COINS++;
+	// }
+	// } else if (random.nextInt(4) == 0) {
+	// if (random.nextInt(4) == 0) {
+	// setBlock(x, floor - 4, (byte) (2 + 1 * 16));
+	// } else {
+	// setBlock(x, floor - 4, (byte) (1 + 1 * 16));
+	// }
+	// } else {
+	// setBlock(x, floor - 4, BLOCK_EMPTY);
+	// BLOCKS_EMPTY++;
+	// }
+	// }
+	// }
+	// }
+	// }
+	// }

 	private void fixWalls() {
 		boolean[][] blockMap = new boolean[width + 1][height + 1];