===================================================================
--- original.js
+++ change.js
@@ -381,8 +381,10 @@
 		}
 		// Update corner water
 		if (self.waterCorner) {
 			self.waterCorner.visible = true;
+			self.waterCorner.x = config.cornerPosition.x;
+			self.waterCorner.y = config.cornerPosition.y;
 			self.waterCorner.alpha = Math.min(Math.max(0, ((progress - thirdSize) / thirdSize - 0.5) * 2, 0), 1);
 			var rotationProgress = (progress - thirdSize) / thirdSize;
 			self.waterCorner.rotation = -Math.PI / 2 - rotationProgress * Math.PI / 2;
 			log("WaterCorner visible with alpha:", self.waterCorner.alpha, "and rotation:", self.waterCorner.rotation);
@@ -400,8 +402,10 @@
 		}
 		// Set corner to final state
 		if (self.waterCorner) {
 			self.waterCorner.visible = true;
+			self.waterCorner.x = config.cornerPosition.x;
+			self.waterCorner.y = config.cornerPosition.y;
 			self.waterCorner.alpha = 1;
 			self.waterCorner.rotation = -Math.PI;
 			log("WaterCorner fully visible with rotation:", self.waterCorner.rotation);
 		}
@@ -410,8 +414,9 @@
 			secondary.visible = true;
 			secondary[config.secondaryGrowth.property] = Math.min(progress - thirdSize * 2, sidesSize) * config.secondaryGrowth.direction;
 			secondary.x = config.secondaryGrowth.position.x;
 			secondary.y = config.secondaryGrowth.position.y;
+			secondary.rotation = config.secondaryGrowth.rotation;
 			if (config.secondaryGrowth.direction < 0) {
 				secondary['scale' + (config.secondaryGrowth.property === 'width' ? 'X' : 'Y')] = -1;
 			}
 			log("Secondary water visible with size:", secondary[config.secondaryGrowth.property]);
@@ -824,30 +829,22 @@
 
 /**** 
 * Game Code
 ****/ 
+function _typeof2(o) {
+	"@babel/helpers - typeof";
+	return _typeof2 = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) {
+		return typeof o;
+	} : function (o) {
+		return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
+	}, _typeof2(o);
+}
 function _slicedToArray2(r, e) {
 	return _arrayWithHoles2(r) || _iterableToArrayLimit2(r, e) || _unsupportedIterableToArray2(r, e) || _nonIterableRest2();
 }
 function _nonIterableRest2() {
 	throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
 }
-function _unsupportedIterableToArray2(r, a) {
-	if (r) {
-		if ("string" == typeof r) {
-			return _arrayLikeToArray2(r, a);
-		}
-		var t = {}.toString.call(r).slice(8, -1);
-		return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray2(r, a) : void 0;
-	}
-}
-function _arrayLikeToArray2(r, a) {
-	(null == a || a > r.length) && (a = r.length);
-	for (var e = 0, n = Array(a); e < a; e++) {
-		n[e] = r[e];
-	}
-	return n;
-}
 function _iterableToArrayLimit2(r, l) {
 	var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
 	if (null != t) {
 		var e,
@@ -888,8 +885,87 @@
 	if (Array.isArray(r)) {
 		return r;
 	}
 }
+function _toConsumableArray(r) {
+	return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray2(r) || _nonIterableSpread();
+}
+function _nonIterableSpread() {
+	throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _unsupportedIterableToArray2(r, a) {
+	if (r) {
+		if ("string" == typeof r) {
+			return _arrayLikeToArray2(r, a);
+		}
+		var t = {}.toString.call(r).slice(8, -1);
+		return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray2(r, a) : void 0;
+	}
+}
+function _iterableToArray(r) {
+	if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) {
+		return Array.from(r);
+	}
+}
+function _arrayWithoutHoles(r) {
+	if (Array.isArray(r)) {
+		return _arrayLikeToArray2(r);
+	}
+}
+function _arrayLikeToArray2(r, a) {
+	(null == a || a > r.length) && (a = r.length);
+	for (var e = 0, n = Array(a); e < a; e++) {
+		n[e] = r[e];
+	}
+	return n;
+}
+function ownKeys(e, r) {
+	var t = Object.keys(e);
+	if (Object.getOwnPropertySymbols) {
+		var o = Object.getOwnPropertySymbols(e);
+		r && (o = o.filter(function (r) {
+			return Object.getOwnPropertyDescriptor(e, r).enumerable;
+		})), t.push.apply(t, o);
+	}
+	return t;
+}
+function _objectSpread(e) {
+	for (var r = 1; r < arguments.length; r++) {
+		var t = null != arguments[r] ? arguments[r] : {};
+		r % 2 ? ownKeys(Object(t), !0).forEach(function (r) {
+			_defineProperty2(e, r, t[r]);
+		}) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) {
+			Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r));
+		});
+	}
+	return e;
+}
+function _defineProperty2(e, r, t) {
+	return (r = _toPropertyKey2(r)) in e ? Object.defineProperty(e, r, {
+		value: t,
+		enumerable: !0,
+		configurable: !0,
+		writable: !0
+	}) : e[r] = t, e;
+}
+function _toPropertyKey2(t) {
+	var i = _toPrimitive2(t, "string");
+	return "symbol" == _typeof2(i) ? i : i + "";
+}
+function _toPrimitive2(t, r) {
+	if ("object" != _typeof2(t) || !t) {
+		return t;
+	}
+	var e = t[Symbol.toPrimitive];
+	if (void 0 !== e) {
+		var i = e.call(t, r || "default");
+		if ("object" != _typeof2(i)) {
+			return i;
+		}
+		throw new TypeError("@@toPrimitive must return a primitive value.");
+	}
+	return ("string" === r ? String : Number)(t);
+}
 function _typeof(o) {
 	"@babel/helpers - typeof";
 	return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) {
 		return typeof o;
@@ -1381,16 +1457,8 @@
 			}
 		}
 		return false;
 	};
-	self.generateNewLevel = function () {
-		var existingLevels = Object.values(self.levelConfigs);
-		var newLevel = generateLevel(existingLevels);
-		var levelNumber = Object.keys(self.levelConfigs).length + 1;
-		self.levelConfigs[levelNumber] = newLevel;
-		log("Generated new level:", levelNumber, newLevel);
-		return newLevel;
-	};
 	return this;
 };
 /**** 
 * Game Variables
@@ -1492,109 +1560,61 @@
 			}, 75); // Adjust the interval for desired speed
 		}
 	}, 50); // Adjust the interval for desired speed
 }
-function generateLevel(existingLevels) {
-	var gridSize = 4;
-	var tiles = Array(gridSize).fill(null).map(function () {
-		return Array(gridSize).fill(null);
-	});
-	var rotations = {};
-	var fixedTiles = [];
-	// Helper function to get valid pipe positions
-	function getValidPositions(x, y, type, rotation) {
-		var positions = [];
-		if (type === 'start') {
-			positions.push([x, y + 1]); // Down
-		} else if (type === 'end') {
-			positions.push([x, y - 1]); // Up
-		} else if (type === 'straightPipeV') {
-			positions.push([x, y - 1], [x, y + 1]); // Up and Down
-		} else if (type === 'straightPipeH') {
-			positions.push([x - 1, y], [x + 1, y]); // Left and Right
-		} else if (type === 'cornerPipe') {
-			if (rotation === 'right') {
-				positions.push([x - 1, y], [x, y + 1]); // Left and Down
-			} else if (rotation === 'left') {
-				positions.push([x + 1, y], [x, y + 1]); // Right and Down
-			}
-		}
-		return positions.filter(function (_ref) {
-			var _ref2 = _slicedToArray2(_ref, 2),
-				px = _ref2[0],
-				py = _ref2[1];
-			return px >= 0 && px < gridSize && py >= 0 && py < gridSize;
-		});
-	}
-	// Place start tile randomly on the top row
-	var startX = Math.floor(Math.random() * gridSize);
-	tiles[0][startX] = 'start';
-	fixedTiles.push("0,".concat(startX));
-	// Place end tile randomly on the bottom row
-	var endX = Math.floor(Math.random() * gridSize);
-	tiles[gridSize - 1][endX] = 'end';
-	rotations["".concat(gridSize - 1, ",").concat(endX)] = 'left';
-	fixedTiles.push("".concat(gridSize - 1, ",").concat(endX));
-	// Generate path between start and end
-	var currentX = startX;
-	var currentY = 0;
-	var path = [[currentX, currentY]];
-	while (currentY < gridSize - 1) {
-		var nextX = currentX;
-		var nextY = currentY + 1;
-		// Add some randomness to path direction
-		if (Math.random() < 0.4 && nextY < gridSize - 1) {
-			if (currentX < endX && currentX < gridSize - 1) {
-				nextX = currentX + 1;
-			} else if (currentX > endX && currentX > 0) {
-				nextX = currentX - 1;
-			}
-		}
-		// Place appropriate pipe type
-		if (nextX === currentX) {
-			tiles[currentY][currentX] = 'straightPipeV';
-		} else {
-			tiles[currentY][currentX] = 'cornerPipe';
-			rotations["".concat(currentY, ",").concat(currentX)] = nextX > currentX ? 'right' : 'left';
-			tiles[nextY][nextX] = 'straightPipeH';
-		}
-		// Fix some tiles randomly to increase difficulty
-		if (Math.random() < 0.3) {
-			fixedTiles.push("".concat(currentY, ",").concat(currentX));
-		}
-		currentX = nextX;
-		currentY = nextY;
-		path.push([currentX, currentY]);
-	}
-	// Add some decoy pipes
-	var decoyCount = Math.min(3, Math.floor(existingLevels.length / 2));
-	for (var i = 0; i < decoyCount; i++) {
-		var x = Math.floor(Math.random() * gridSize);
-		var y = Math.floor(Math.random() * gridSize);
-		if (!tiles[y][x]) {
-			tiles[y][x] = Math.random() < 0.5 ? 'straightPipeH' : 'straightPipeV';
-		}
-	}
-	return {
-		tiles: tiles,
-		rotations: rotations,
-		fixedTiles: fixedTiles
-	};
-}
 /**** 
 * Game State Management
 ****/ 
 function initializeGame() {
-	// Create puzzle manager
+	// Init and Add backgroundLayer
+	backgroundLayer = new Container();
+	middleLayer = new Container();
+	game.addChild(backgroundLayer);
+	// Initialize grid board
+	gridBoard = LK.getAsset('gridBoard', {
+		anchorX: 0.5,
+		anchorY: 0.5,
+		visible: false
+	});
+	gridBoard.x = 2048 / 2;
+	gridBoard.y = 2732 / 2;
+	game.addChild(gridBoard);
+	// Initialize grid board soil
+	gridBoardSoil = LK.getAsset('gridBoardSoil', {
+		anchorX: 0.5,
+		anchorY: 0.5,
+		visible: false,
+		alpha: 0
+	});
+	gridBoardSoil.x = 2048 / 2 + 20;
+	gridBoardSoil.y = 2732 / 2 - 20;
+	game.addChild(gridBoardSoil);
+	game.addChild(middleLayer);
+	// Create growGrass asset
+	growGrass = LK.getAsset('growGrass', {
+		anchorX: 0.5,
+		anchorY: 0.5,
+		visible: false,
+		alpha: 0
+	});
+	growGrass.x = 2048 / 2 + 20;
+	growGrass.y = 2732 / 2;
+	middleLayer.addChild(growGrass);
+	// Initialize game assets and variables
 	puzzleManager = new PuzzleManager();
-	// Generate additional levels beyond the initial ones
-	var initialLevelCount = Object.keys(puzzleManager.levelConfigs).length;
-	for (var i = initialLevelCount + 1; i <= puzzleManager.maxLevels; i++) {
-		puzzleManager.generateNewLevel();
-	}
-	// Initialize the game state
-	gameState = 'menu';
-	changeGameState('menu');
+	// Initialize level text
+	levelText = new Text2("Level 1", {
+		size: 100,
+		fill: 0xFFFFFF
+	});
+	levelText.x = 2048 / 2;
+	levelText.y = 200;
+	levelText.anchorX = 0.5;
+	levelText.visible = false;
+	// Add the level text to the game
+	game.addChild(levelText);
+	// Transition to menu state
+	changeGameState(GAME_STATE.MENU);
 }
 function initMenuState() {
 	// Show level selection UI
 	console.log("Entering Menu State");
@@ -1823,5 +1843,91 @@
 		}
 	}
 }
 // Start the game
-initializeGame();
\ No newline at end of file
+initializeGame();
+//
+// Level generator function that creates progressively challenging levels
+function generateNextLevel(existingLevels) {
+	// Get the last level configuration as base
+	var lastLevel = existingLevels[existingLevels.length - 1];
+	if (!lastLevel) {
+		throw new Error("No existing levels to base the new level on.");
+	}
+	// Deep clone the last level to avoid modifying it
+	var newLevel = {
+		tiles: JSON.parse(JSON.stringify(lastLevel.tiles)),
+		rotations: _objectSpread({}, lastLevel.rotations),
+		fixedTiles: _toConsumableArray(lastLevel.fixedTiles)
+	};
+	// Find empty spaces in the grid
+	var emptySpaces = [];
+	for (var y = 0; y < 4; y++) {
+		for (var x = 0; x < 4; x++) {
+			if (!newLevel.tiles[y][x] && !isStartOrEnd(newLevel.tiles[y][x])) {
+				emptySpaces.push([x, y]);
+			}
+		}
+	}
+	// Add 1-2 new pipes in empty spaces
+	var numNewPipes = Math.min(1 + Math.floor(Math.random() * 2), emptySpaces.length);
+	for (var i = 0; i < numNewPipes; i++) {
+		var spaceIndex = Math.floor(Math.random() * emptySpaces.length);
+		var _emptySpaces$spaceInd = _slicedToArray2(emptySpaces[spaceIndex], 2),
+			x = _emptySpaces$spaceInd[0],
+			y = _emptySpaces$spaceInd[1];
+		emptySpaces.splice(spaceIndex, 1);
+		// Add either straightPipeH, straightPipeV, or cornerPipe
+		var pipeTypes = ['straightPipeH', 'straightPipeV', 'cornerPipe'];
+		var newPipe = pipeTypes[Math.floor(Math.random() * pipeTypes.length)];
+		newLevel.tiles[y][x] = newPipe;
+		// If it's a corner pipe, add rotation
+		if (newPipe === 'cornerPipe') {
+			newLevel.rotations["".concat(y, ",").concat(x)] = Math.random() < 0.5 ? 'left' : 'right';
+		}
+		// 70% chance to make it fixed
+		if (Math.random() < 0.7) {
+			newLevel.fixedTiles.push("".concat(y, ",").concat(x));
+		}
+	}
+	// Randomly unfix one previously fixed tile to increase difficulty
+	var removableFixed = newLevel.fixedTiles.filter(function (pos) {
+		var _pos$split$map2 = pos.split(',').map(Number),
+			_pos$split$map3 = _slicedToArray2(_pos$split$map2, 2),
+			y = _pos$split$map3[0],
+			x = _pos$split$map3[1];
+		return !isStartOrEnd(newLevel.tiles[y][x]);
+	});
+	if (removableFixed.length > 0) {
+		var indexToRemove = Math.floor(Math.random() * removableFixed.length);
+		newLevel.fixedTiles = newLevel.fixedTiles.filter(function (pos) {
+			return pos !== removableFixed[indexToRemove];
+		});
+	}
+	return newLevel;
+}
+// Helper function to check if a tile is start or end
+function isStartOrEnd(tileType) {
+	return tileType === 'start' || tileType === 'end';
+}
+// Get existing levels from the PuzzleManager
+var existingLevels = [
+// Level 1
+{
+	tiles: [['start', 'straightPipeV', 'straightPipeV', 'cornerPipe'], [null, null, null, 'straightPipeH'], [null, null, 'straightPipeH', null], [null, null, null, 'end']],
+	rotations: {
+		'0,3': 'right',
+		'3,3': 'left'
+	},
+	fixedTiles: ['0,0', '0,1', '0,2', '0,3', '1,3', '3,3']
+},
+// Level 2
+{
+	tiles: [[null, 'straightPipeH', 'end', null], [null, 'cornerPipe', 'straightPipeH', null], [null, null, null, null], ['start', 'straightPipeV', null, null]],
+	rotations: {
+		'0,2': 'right',
+		'1,1': 'left'
+	},
+	fixedTiles: ['3,0', '3,1', '0,2', '1,2']
+}];
+// Generate and log a new level
+console.log("Generated Level:", generateNextLevel(existingLevels));
\ No newline at end of file