===================================================================
--- original.js
+++ change.js
@@ -244,8 +244,290 @@
 			rotation: Math.PI * 0.5,
 			tint: self.baseTintLight
 		});
 	};
+	self.getCornerPipeConfig = function () {
+		// Define the water flow configuration based on normalized rotation
+		var configs = _defineProperty(_defineProperty(_defineProperty(_defineProperty({}, Math.PI / 2, {
+			// right
+			primaryWater: 'waterV',
+			secondaryWater: 'waterH',
+			primaryGrowth: {
+				property: 'height',
+				direction: 1,
+				position: {
+					x: -120,
+					y: -5
+				},
+				rotation: -Math.PI / 2
+			},
+			secondaryGrowth: {
+				property: 'width',
+				direction: 1,
+				position: {
+					x: -5,
+					y: -50
+				},
+				rotation: -Math.PI / 2
+			},
+			cornerPosition: {
+				x: -65,
+				y: -65
+			}
+		}), 0, {
+			// up
+			primaryWater: 'waterH',
+			secondaryWater: 'waterV',
+			primaryGrowth: {
+				property: 'width',
+				direction: -1,
+				position: {
+					x: -5,
+					y: -50
+				},
+				rotation: -Math.PI / 2
+			},
+			secondaryGrowth: {
+				property: 'height',
+				direction: 1,
+				position: {
+					x: -120,
+					y: -5
+				},
+				rotation: -Math.PI / 2
+			},
+			cornerPosition: {
+				x: -65,
+				y: -65
+			}
+		}), Math.PI, {
+			// down
+			primaryWater: 'waterH',
+			secondaryWater: 'waterV',
+			primaryGrowth: {
+				property: 'width',
+				direction: 1,
+				position: {
+					x: -5,
+					y: -50
+				},
+				rotation: -Math.PI / 2
+			},
+			secondaryGrowth: {
+				property: 'height',
+				direction: -1,
+				position: {
+					x: -120,
+					y: -5
+				},
+				rotation: -Math.PI / 2
+			},
+			cornerPosition: {
+				x: -65,
+				y: -65
+			}
+		}), Math.PI * 1.5, {
+			// left
+			primaryWater: 'waterV',
+			secondaryWater: 'waterH',
+			primaryGrowth: {
+				property: 'height',
+				direction: -1,
+				position: {
+					x: -120,
+					y: -5
+				},
+				rotation: -Math.PI / 2
+			},
+			secondaryGrowth: {
+				property: 'width',
+				direction: -1,
+				position: {
+					x: -5,
+					y: -50
+				},
+				rotation: -Math.PI / 2
+			},
+			cornerPosition: {
+				x: -65,
+				y: -65
+			}
+		});
+		return configs[self.normalizedRotation] || configs[0];
+	};
+	self.updateCornerPipeFirstPhase = function (progress, thirdSize) {
+		log("Progress in first third:", progress);
+		var config = self.getCornerPipeConfig();
+		var primary = self[config.primaryWater];
+		if (primary) {
+			primary.visible = true;
+			primary[config.primaryGrowth.property] = progress * config.primaryGrowth.direction;
+			primary.x = config.primaryGrowth.position.x;
+			primary.y = config.primaryGrowth.position.y;
+			primary.rotation = config.primaryGrowth.rotation;
+			if (config.primaryGrowth.direction < 0) {
+				primary['scale' + (config.primaryGrowth.property === 'width' ? 'X' : 'Y')] = -1;
+			}
+			log("Primary water set to:", primary[config.primaryGrowth.property]);
+		}
+	};
+	self.updateCornerPipeSecondPhase = function (progress, thirdSize) {
+		log("Progress in second third:", progress);
+		var config = self.getCornerPipeConfig();
+		var primary = self[config.primaryWater];
+		// Keep primary at max
+		if (primary) {
+			primary[config.primaryGrowth.property] = thirdSize * config.primaryGrowth.direction;
+			log("Primary water at max:", primary[config.primaryGrowth.property]);
+		}
+		// 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);
+		}
+	};
+	self.updateCornerPipeThirdPhase = function (progress, thirdSize, sidesSize) {
+		log("Progress in final third:", progress);
+		var config = self.getCornerPipeConfig();
+		var primary = self[config.primaryWater];
+		var secondary = self[config.secondaryWater];
+		// Keep primary at max
+		if (primary) {
+			primary[config.primaryGrowth.property] = thirdSize * config.primaryGrowth.direction;
+			log("Primary water at max:", primary[config.primaryGrowth.property]);
+		}
+		// 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);
+		}
+		// Grow secondary pipe
+		if (secondary) {
+			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]);
+		}
+	};
+	self.updateEndTile = function () {
+		if (self.fountain) {
+			var sizeValue = (LK.ticks - self.startFlowTicks) * self.flowSpeed;
+			if (sizeValue < self.maxWaterSize) {
+				self.fountain.width = sizeValue;
+				self.fountain.height = sizeValue;
+				if (!self.fountain.visible) {
+					self.fountain.visible = true;
+					LK.getSound('fountain').play();
+				}
+			} else {
+				self.flow = false;
+				if (!waterDropInterval) {
+					createWaterDrops(self.x, self.y, game);
+					waterDropInterval = LK.setInterval(function () {
+						createWaterDrops(self.x, self.y, game);
+					}, 500 + Math.random() * 500);
+					animateSoil();
+				}
+			}
+		}
+	};
+	self.updateRegularPipe = function () {
+		if (self.water) {
+			var heightValue = (LK.ticks - self.startFlowTicks) * self.flowSpeed;
+			if (heightValue < self.maxWaterSize) {
+				self.water.visible = true;
+				if (self.water.dir === 'lr') {
+					self.water.width = heightValue;
+					self.water.x = -130;
+					self.water.scaleX = 1;
+				} else if (self.water.dir === 'rl') {
+					self.water.width = heightValue;
+					self.water.x = 130;
+					self.water.scaleX = -1;
+				} else if (self.water.dir === 'tb') {
+					self.water.height = heightValue;
+					self.water.y = -130;
+					self.water.scaleY = 1;
+				} else if (self.water.dir === 'bt') {
+					self.water.height = heightValue;
+					self.water.y = 130;
+					self.water.scaleY = -1;
+				} else {
+					self.water.height = heightValue;
+				}
+			} else {
+				self.flow = false;
+			}
+		}
+	};
+	self.updateEndTileAnimation = function () {
+		if (self.type === 'end' && self.fountain && self.fountain.visible) {
+			self.fountain.rotation += 0.1;
+			var sizeVariation = 30 * Math.sin(LK.ticks * 0.1);
+			self.fountain.width = 250 + sizeVariation;
+			self.fountain.height = 250 + sizeVariation;
+		}
+	};
+	self.updateCornerPipe = function () {
+		var progress = (LK.ticks - self.startFlowTicks) * self.flowSpeed;
+		var thirdSize = self.maxWaterSize / 3 - 10;
+		var sidesSize = self.maxWaterSize / 3;
+		if (progress < thirdSize) {
+			self.updateCornerPipeFirstPhase(progress, thirdSize);
+		} else if (progress < thirdSize * 2) {
+			self.updateCornerPipeSecondPhase(progress, thirdSize);
+		} else {
+			self.updateCornerPipeThirdPhase(progress, thirdSize, sidesSize);
+		}
+		if (progress >= self.maxWaterSize) {
+			self.flow = false;
+		}
+	};
+	self.update = function () {
+		if (self.flow) {
+			if (!self.startFlowTicks) {
+				self.startFlowTicks = LK.ticks;
+				if (self.water) {
+					self.water.visible = true;
+				}
+				if (self.waterV) {
+					self.waterV.visible = true;
+				}
+				if (self.waterH) {
+					self.waterH.visible = true;
+				}
+			}
+			switch (self.type) {
+				case 'start':
+					self.updateStartTile();
+					break;
+				case 'cornerPipe':
+					self.updateCornerPipe();
+					break;
+				case 'end':
+					self.updateEndTile();
+					break;
+				default:
+					self.updateRegularPipe();
+					break;
+			}
+		}
+		self.updateEndTileAnimation();
+	};
 	self.setType = function (type, x, y) {
 		self.type = type;
 		var baseTileAsset = type == 'start' || type == 'end' || puzzleManager && puzzleManager.levelConfigs && puzzleManager.levelConfigs[puzzleManager.currentLevel] && puzzleManager.levelConfigs[puzzleManager.currentLevel].fixedTiles && puzzleManager.levelConfigs[puzzleManager.currentLevel].fixedTiles.includes(x + ',' + y) ? 'baseTile' : 'baseMobileTile';
 		if (type == 'empty') {
@@ -443,31 +725,30 @@
 		if (rotationValue >= Math.PI * 3) {
 			self.flow = false;
 		}
 	};
-	self.updateCornerPipeFirstPhase = function (progress, thirdSize, isRotatedRight) {
+	self.updateCornerPipeFirstPhase = function (progress, thirdSize) {
 		log("Progress in first third:", progress);
-		if (isRotatedRight) {
-			if (self.waterV) {
-				self.waterV.height = progress;
-				log("WaterV height set to:", self.waterV.height);
+		var config = self.getCornerPipeConfig();
+		var primary = self[config.primaryWater];
+		if (primary) {
+			primary[config.primaryGrowth.property] = progress * config.primaryGrowth.direction;
+			primary.x = config.primaryGrowth.position.x;
+			primary.y = config.primaryGrowth.position.y;
+			if (config.primaryGrowth.direction < 0) {
+				primary['scale' + (config.primaryGrowth.property === 'width' ? 'X' : 'Y')] = -1;
 			}
-		} else {
-			if (self.waterH) {
-				self.waterH.width = progress;
-				log("WaterH width set to:", self.waterH.width);
-			}
+			log("Primary water set to:", primary[config.primaryGrowth.property]);
 		}
 	};
-	self.updateCornerPipeSecondPhase = function (progress, thirdSize, isRotatedRight) {
+	self.updateCornerPipeSecondPhase = function (progress, thirdSize) {
 		log("Progress in second third:", progress);
-		// Set primary pipe to max
-		if (isRotatedRight && self.waterV) {
-			self.waterV.height = thirdSize;
-			log("WaterV height set to max thirdSize:", self.waterV.height);
-		} else if (!isRotatedRight && self.waterH) {
-			self.waterH.width = thirdSize;
-			log("WaterH width set to max thirdSize:", self.waterH.width);
+		var config = self.getCornerPipeConfig();
+		var primary = self[config.primaryWater];
+		// Keep primary at max
+		if (primary) {
+			primary[config.primaryGrowth.property] = thirdSize * config.primaryGrowth.direction;
+			log("Primary water at max:", primary[config.primaryGrowth.property]);
 		}
 		// Update corner water
 		if (self.waterCorner) {
 			self.waterCorner.visible = true;
@@ -476,17 +757,17 @@
 			self.waterCorner.rotation = -Math.PI / 2 - rotationProgress * Math.PI / 2;
 			log("WaterCorner visible with alpha:", self.waterCorner.alpha, "and rotation:", self.waterCorner.rotation);
 		}
 	};
-	self.updateCornerPipeThirdPhase = function (progress, thirdSize, sidesSize, isRotatedRight) {
+	self.updateCornerPipeThirdPhase = function (progress, thirdSize, sidesSize) {
 		log("Progress in final third:", progress);
-		// Keep primary pipe at max
-		if (isRotatedRight && self.waterV) {
-			self.waterV.height = thirdSize;
-			log("WaterV height set to max thirdSize:", self.waterV.height);
-		} else if (!isRotatedRight && self.waterH) {
-			self.waterH.width = thirdSize;
-			log("WaterH width set to max thirdSize:", self.waterH.width);
+		var config = self.getCornerPipeConfig();
+		var primary = self[config.primaryWater];
+		var secondary = self[config.secondaryWater];
+		// Keep primary at max
+		if (primary) {
+			primary[config.primaryGrowth.property] = thirdSize * config.primaryGrowth.direction;
+			log("Primary water at max:", primary[config.primaryGrowth.property]);
 		}
 		// Set corner to final state
 		if (self.waterCorner) {
 			self.waterCorner.visible = true;
@@ -494,125 +775,19 @@
 			self.waterCorner.rotation = -Math.PI;
 			log("WaterCorner fully visible with rotation:", self.waterCorner.rotation);
 		}
 		// Grow secondary pipe
-		if (isRotatedRight && self.waterH) {
-			self.waterH.visible = true;
-			self.waterH.width = Math.min(progress - thirdSize * 2, sidesSize);
-			log("WaterH visible with width:", self.waterH.width);
-		} else if (!isRotatedRight && self.waterV) {
-			self.waterV.visible = true;
-			self.waterV.height = Math.min(progress - thirdSize * 2, sidesSize);
-			log("WaterV visible with height:", self.waterV.height);
-		}
-	};
-	self.updateCornerPipe = function () {
-		var progress = (LK.ticks - self.startFlowTicks) * self.flowSpeed;
-		var thirdSize = self.maxWaterSize / 3 - 10;
-		var sidesSize = self.maxWaterSize / 3;
-		var isRotatedRight = self.normalizedRotation === Math.PI / 2;
-		log("Not rotated right, progress:", progress);
-		if (progress < thirdSize) {
-			self.updateCornerPipeFirstPhase(progress, thirdSize, isRotatedRight);
-		} else if (progress < thirdSize * 2) {
-			self.updateCornerPipeSecondPhase(progress, thirdSize, isRotatedRight);
-		} else {
-			self.updateCornerPipeThirdPhase(progress, thirdSize, sidesSize, isRotatedRight);
-		}
-		if (progress >= self.maxWaterSize) {
-			self.flow = false;
-		}
-	};
-	self.updateEndTile = function () {
-		if (self.fountain) {
-			var sizeValue = (LK.ticks - self.startFlowTicks) * self.flowSpeed;
-			if (sizeValue < self.maxWaterSize) {
-				self.fountain.width = sizeValue;
-				self.fountain.height = sizeValue;
-				if (!self.fountain.visible) {
-					self.fountain.visible = true;
-					LK.getSound('fountain').play();
-				}
-			} else {
-				self.flow = false;
-				if (!waterDropInterval) {
-					createWaterDrops(self.x, self.y, game);
-					waterDropInterval = LK.setInterval(function () {
-						createWaterDrops(self.x, self.y, game);
-					}, 500 + Math.random() * 500);
-					animateSoil();
-				}
+		if (secondary) {
+			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;
+			if (config.secondaryGrowth.direction < 0) {
+				secondary['scale' + (config.secondaryGrowth.property === 'width' ? 'X' : 'Y')] = -1;
 			}
+			log("Secondary water visible with size:", secondary[config.secondaryGrowth.property]);
 		}
 	};
-	self.updateRegularPipe = function () {
-		if (self.water) {
-			var heightValue = (LK.ticks - self.startFlowTicks) * self.flowSpeed;
-			if (heightValue < self.maxWaterSize) {
-				self.water.visible = true;
-				if (self.water.dir === 'lr') {
-					self.water.width = heightValue;
-					self.water.x = -130;
-					self.water.scaleX = 1;
-				} else if (self.water.dir === 'rl') {
-					self.water.width = heightValue;
-					self.water.x = 130;
-					self.water.scaleX = -1;
-				} else if (self.water.dir === 'tb') {
-					self.water.height = heightValue;
-					self.water.y = -130;
-					self.water.scaleY = 1;
-				} else if (self.water.dir === 'bt') {
-					self.water.height = heightValue;
-					self.water.y = 130;
-					self.water.scaleY = -1;
-				} else {
-					self.water.height = heightValue;
-				}
-			} else {
-				self.flow = false;
-			}
-		}
-	};
-	self.updateEndTileAnimation = function () {
-		if (self.type === 'end' && self.fountain && self.fountain.visible) {
-			self.fountain.rotation += 0.1;
-			var sizeVariation = 30 * Math.sin(LK.ticks * 0.1);
-			self.fountain.width = 250 + sizeVariation;
-			self.fountain.height = 250 + sizeVariation;
-		}
-	};
-	self.update = function () {
-		if (self.flow) {
-			if (!self.startFlowTicks) {
-				self.startFlowTicks = LK.ticks;
-				if (self.water) {
-					self.water.visible = true;
-				}
-				if (self.waterV) {
-					self.waterV.visible = true;
-				}
-				if (self.waterH) {
-					self.waterH.visible = true;
-				}
-			}
-			switch (self.type) {
-				case 'start':
-					self.updateStartTile();
-					break;
-				case 'cornerPipe':
-					self.updateCornerPipe();
-					break;
-				case 'end':
-					self.updateEndTile();
-					break;
-				default:
-					self.updateRegularPipe();
-					break;
-			}
-		}
-		self.updateEndTileAnimation();
-	};
 	self.setType(self.type);
 	return self;
 });
 var WaterDrop = Container.expand(function () {
@@ -654,8 +829,79 @@
 
 /**** 
 * 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
+			}
+		}
+	}
+	// 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';
+	}
+	// 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 newLevel;
+}
+function isLevelSolvable(level) {
+	// Placeholder function to check if a level is solvable
+	// Implement actual logic to check solvability
+	return true;
+}
+// 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;
+	} : function (o) {
+		return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
+	}, _typeof(o);
+}
+function _defineProperty(e, r, t) {
+	return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+		value: t,
+		enumerable: !0,
+		configurable: !0,
+		writable: !0
+	}) : e[r] = t, e;
+}
+function _toPropertyKey(t) {
+	var i = _toPrimitive(t, "string");
+	return "symbol" == _typeof(i) ? i : i + "";
+}
+function _toPrimitive(t, r) {
+	if ("object" != _typeof(t) || !t) {
+		return t;
+	}
+	var e = t[Symbol.toPrimitive];
+	if (void 0 !== e) {
+		var i = e.call(t, r || "default");
+		if ("object" != _typeof(i)) {
+			return i;
+		}
+		throw new TypeError("@@toPrimitive must return a primitive value.");
+	}
+	return ("string" === r ? String : Number)(t);
+}
 function _slicedToArray(r, e) {
 	return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest();
 }
 function _nonIterableRest() {