===================================================================
--- original.js
+++ change.js
@@ -381,10 +381,8 @@
 		}
 		// 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);
@@ -402,10 +400,8 @@
 		}
 		// 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);
 		}
@@ -414,9 +410,8 @@
 			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]);
@@ -829,47 +824,72 @@
 
 /**** 
 * Game Code
 ****/ 
-function generateNewLevel(existingLevels) {
-	// Clone the last level to use as a base for the new level
-	var newLevel = JSON.parse(JSON.stringify(existingLevels[existingLevels.length - 1]));
-	// Increase the grid size by adding 1-2 new tiles
-	newLevel.tiles.push(new Array(newLevel.gridSize).fill(null));
-	newLevel.gridSize += 1;
-	// Randomly modify some tiles to increase difficulty
-	for (var i = 0; i < newLevel.gridSize; i++) {
-		for (var j = 0; j < newLevel.gridSize; j++) {
-			if (Math.random() < 0.1) {
-				// 10% chance to change a tile
-				newLevel.tiles[i][j] = 'cornerPipe'; // Example change
-			}
+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;
 	}
-	// Ensure the new level is solvable
-	while (!isLevelSolvable(newLevel)) {
-		// Modify the level until it becomes solvable
-		// This is a placeholder logic, replace with actual solvability check and modification
-		newLevel.tiles[Math.floor(Math.random() * newLevel.gridSize)][Math.floor(Math.random() * newLevel.gridSize)] = 'straightPipeH';
+}
+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];
 	}
-	// Ensure the new level is unique
-	if (existingLevels.some(function (level) {
-		return JSON.stringify(level) === JSON.stringify(newLevel);
-	})) {
-		return generateNewLevel(existingLevels); // Recursively generate a new level if not unique
+	return n;
+}
+function _iterableToArrayLimit2(r, l) {
+	var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
+	if (null != t) {
+		var e,
+			n,
+			i,
+			u,
+			a = [],
+			f = !0,
+			o = !1;
+		try {
+			if (i = (t = t.call(r)).next, 0 === l) {
+				if (Object(t) !== t) {
+					return;
+				}
+				f = !1;
+			} else {
+				for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0) {
+					;
+				}
+			}
+		} catch (r) {
+			o = !0, n = r;
+		} finally {
+			try {
+				if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) {
+					return;
+				}
+			} finally {
+				if (o) {
+					throw n;
+				}
+			}
+		}
+		return a;
 	}
-	return newLevel;
 }
-function isLevelSolvable(level) {
-	// Placeholder function to check if a level is solvable
-	// Implement actual logic to check solvability
-	return true;
+function _arrayWithHoles2(r) {
+	if (Array.isArray(r)) {
+		return r;
+	}
 }
-// Initialize puzzleManager before using it
-puzzleManager = new PuzzleManager();
-// Call the function after game initialization and log the result
-var newLevel = generateNewLevel(Object.values(puzzleManager.levelConfigs));
-console.log("Generated New Level:", newLevel);
 function _typeof(o) {
 	"@babel/helpers - typeof";
 	return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) {
 		return typeof o;
@@ -1361,8 +1381,16 @@
 			}
 		}
 		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
@@ -1464,61 +1492,109 @@
 			}, 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() {
-	// 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
+	// Create puzzle manager
 	puzzleManager = new PuzzleManager();
-	// 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);
+	// 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');
 }
 function initMenuState() {
 	// Show level selection UI
 	console.log("Entering Menu State");