===================================================================
--- original.js
+++ change.js
@@ -414,9 +414,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]);
@@ -822,15 +821,103 @@
 
 /**** 
 * Initialize Game
 ****/ 
+/**** 
+* Global level configurations
+****/ 
 var game = new LK.Game({
 	backgroundColor: 0x000000
 });
 
 /**** 
 * Game Code
 ****/ 
+/**** 
+* Global level configurations
+****/ 
+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,
+			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;
+	}
+}
+function _arrayWithHoles2(r) {
+	if (Array.isArray(r)) {
+		return r;
+	}
+}
+var levelConfigs = {
+	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']
+	},
+	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']
+	}
+};
 function _typeof(o) {
 	"@babel/helpers - typeof";
 	return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) {
 		return typeof o;
@@ -949,42 +1036,9 @@
 	self.selectedTile = null;
 	self.waterFlowing = false;
 	self.isComplete = false;
 	// Level configurations
-	self.levelConfigs = {
-		1: {
-			tiles: [['start', 'straightPipeV', 'straightPipeV', 'cornerPipe'], [null, null, null, 'straightPipeH'], [null, null, 'straightPipeH', null], [null, null, null, 'end']],
-			rotations: {
-				'0,3': 'right',
-				// corner
-				'3,3': 'left' // end
-			},
-			fixedTiles: ['0,0', '0,1', '0,2', '0,3', '1,3', '3,3'] // All tiles fixed except 2,2
-		},
-		2: {
-			tiles: [[null, 'straightPipeH', 'end', null], [null, 'cornerPipe', 'straightPipeH', null], [null, null, null, null], ['start', 'straightPipeV', null, null]],
-			rotations: {
-				'0,2': 'right',
-				// end
-				'1,1': 'left' // corner
-			},
-			fixedTiles: ['3,0', '3,1', '0,2', '1,2'] // Start, end, and 2 pipes fixed
-		},
-		3: {
-			tiles: [['cornerPipe', null, null, 'straightPipeV'], ['cornerPipe', 'end', null, 'straightPipeH'], [null, null, null, null], [null, null, 'straightPipeV', 'start']],
-			rotations: {
-				'0,0': 'down',
-				// corner 1
-				'1,0': 'up',
-				// corner 2
-				'1,1': 'up',
-				// end
-				'3,3': 'up' // start
-			},
-			fixedTiles: ['1,0', '1,1', '3,2', '3,3'] // Start, end, and 2 pipe fixed
-		}
-		// Add more levels here
-	};
+	self.levelConfigs = levelConfigs;
 	self.initPuzzle = function () {
 		log("Initializing puzzle for level", self.currentLevel);
 		// Clear existing grid
 		self.grid = [];
@@ -1362,9 +1416,247 @@
 var waterDrops = [];
 var waterDropInterval;
 var logo;
 var puzzleManager;
+// Initialize the game
+initializeGame();
 /**** 
+* Level Generator and Converter Code
+****/ 
+// Convert ASCII art to level configuration with automatic rotations
+var stringToLevel = function stringToLevel(levelString) {
+	var lines = levelString.trim().split('\n').map(function (line) {
+		return line.trim();
+	});
+	var gridSize = 4;
+	var tiles = [];
+	var rotations = {};
+	var fixedTiles = [];
+	var startPos = null;
+	var endPos = null;
+	var cornerPipes = [];
+	// Initialize tiles array
+	for (var i = 0; i < gridSize; i++) {
+		tiles[i] = [];
+		for (var j = 0; j < gridSize; j++) {
+			tiles[i][j] = null;
+		}
+	}
+	// First pass: Place all tiles except rotations
+	for (var y = 0; y < lines.length && y < gridSize; y++) {
+		var chars = lines[y].split('');
+		for (var x = 0; x < chars.length && x < gridSize; x++) {
+			var _char = chars[x];
+			switch (_char) {
+				case 'S':
+					tiles[y][x] = 'start';
+					fixedTiles.push(y + ',' + x);
+					startPos = [y, x];
+					break;
+				case 'E':
+					tiles[y][x] = 'end';
+					fixedTiles.push(y + ',' + x);
+					endPos = [y, x];
+					break;
+				case '|':
+					tiles[y][x] = 'straightPipeV';
+					break;
+				case '-':
+					tiles[y][x] = 'straightPipeH';
+					break;
+				case 'C':
+					tiles[y][x] = 'cornerPipe';
+					cornerPipes.push([y, x]);
+					break;
+				case 'F':
+					// Fixed straight pipe vertical
+					tiles[y][x] = 'straightPipeV';
+					fixedTiles.push(y + ',' + x);
+					break;
+				case '=':
+					// Fixed straight pipe horizontal
+					tiles[y][x] = 'straightPipeH';
+					fixedTiles.push(y + ',' + x);
+					break;
+				case '.':
+				case ' ':
+					tiles[y][x] = null;
+					break;
+			}
+		}
+	}
+	// Helper function to check if a path exists from start to end
+	function isValidPath(config) {
+		var visited = [];
+		var startRotation = config.rotations[startPos[0] + ',' + startPos[1]] || 'down';
+		function canReachEnd(x, y, fromDir) {
+			if (x < 0 || x >= gridSize || y < 0 || y >= gridSize) {
+				return false;
+			}
+			var key = x + ',' + y;
+			if (visited.includes(key)) {
+				return false;
+			}
+			visited.push(key);
+			var tile = config.tiles[x][y];
+			if (!tile) {
+				return false;
+			}
+			if (tile === 'end') {
+				return true;
+			}
+			var rotation = config.rotations[key] || 'down';
+			var nextPositions = [];
+			switch (tile) {
+				case 'start':
+					switch (rotation) {
+						case 'down':
+							nextPositions.push([x, y + 1]);
+							break;
+						case 'up':
+							nextPositions.push([x, y - 1]);
+							break;
+						case 'left':
+							nextPositions.push([x - 1, y]);
+							break;
+						case 'right':
+							nextPositions.push([x + 1, y]);
+							break;
+					}
+					break;
+				case 'straightPipeV':
+					nextPositions.push([x, y - 1], [x, y + 1]);
+					break;
+				case 'straightPipeH':
+					nextPositions.push([x - 1, y], [x + 1, y]);
+					break;
+				case 'cornerPipe':
+					switch (rotation) {
+						case 'up':
+							nextPositions.push([x - 1, y], [x, y + 1]);
+							break;
+						case 'right':
+							nextPositions.push([x + 1, y], [x, y + 1]);
+							break;
+						case 'down':
+							nextPositions.push([x + 1, y], [x, y - 1]);
+							break;
+						case 'left':
+							nextPositions.push([x - 1, y], [x, y - 1]);
+							break;
+					}
+					break;
+			}
+			for (var i = 0; i < nextPositions.length; i++) {
+				if (canReachEnd(nextPositions[i][0], nextPositions[i][1])) {
+					return true;
+				}
+			}
+			return false;
+		}
+		return canReachEnd(startPos[0], startPos[1]);
+	}
+	// Try all possible rotations
+	var possibleRotations = ['up', 'right', 'down', 'left'];
+	var validConfig = null;
+	function tryRotations(currentConfig, index) {
+		if (index >= cornerPipes.length + 2) {
+			// +2 for start and end tiles
+			if (isValidPath(currentConfig)) {
+				validConfig = JSON.parse(JSON.stringify(currentConfig));
+				return true;
+			}
+			return false;
+		}
+		var pos;
+		var isStartOrEnd = index < 2;
+		if (isStartOrEnd) {
+			pos = index === 0 ? startPos : endPos;
+		} else {
+			pos = cornerPipes[index - 2];
+		}
+		for (var i = 0; i < possibleRotations.length; i++) {
+			var rotation = possibleRotations[i];
+			var key = pos[0] + ',' + pos[1];
+			currentConfig.rotations[key] = rotation;
+			if (tryRotations(currentConfig, index + 1)) {
+				return true;
+			}
+		}
+		return false;
+	}
+	var baseConfig = {
+		tiles: tiles,
+		rotations: {},
+		fixedTiles: fixedTiles
+	};
+	tryRotations(baseConfig, 0);
+	return validConfig || baseConfig;
+};
+// Convert level configuration to ASCII art
+var levelToString = function levelToString(level) {
+	var result = '';
+	for (var y = 0; y < level.tiles.length; y++) {
+		for (var x = 0; x < level.tiles[y].length; x++) {
+			var tile = level.tiles[y][x];
+			var isFixed = level.fixedTiles.includes(y + ',' + x);
+			if (!tile) {
+				result += '.';
+			} else {
+				switch (tile) {
+					case 'start':
+						result += 'S';
+						break;
+					case 'end':
+						result += 'E';
+						break;
+					case 'straightPipeV':
+						result += isFixed ? 'F' : '|';
+						break;
+					case 'straightPipeH':
+						result += isFixed ? '=' : '-';
+						break;
+					case 'cornerPipe':
+						result += 'C';
+						break;
+				}
+			}
+		}
+		result += '\n';
+	}
+	return result;
+};
+// Generate next level using string-based representation
+var generateNextLevel = function generateNextLevel(existingLevels) {
+	var lastLevel = existingLevels[existingLevels.length - 1];
+	var levelStr = levelToString(lastLevel);
+	// For now, just add some random pipes to empty spaces
+	var lines = levelStr.split('\n');
+	var emptySpaces = [];
+	// Find empty spaces
+	for (var y = 0; y < lines.length; y++) {
+		for (var x = 0; x < lines[y].length; x++) {
+			if (lines[y][x] === '.') {
+				emptySpaces.push([x, y]);
+			}
+		}
+	}
+	// Add 1-2 new pipes
+	var numNewPipes = Math.min(1 + Math.floor(Math.random() * 2), emptySpaces.length);
+	var pipeTypes = ['|', '-', 'C'];
+	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 new pipe
+		var newPipe = pipeTypes[Math.floor(Math.random() * pipeTypes.length)];
+		lines[y] = lines[y].substring(0, x) + newPipe + lines[y].substring(x + 1);
+	}
+	return stringToLevel(lines.join('\n'));
+};
+/**** 
 * Helper Functions
 ****/ 
 function createWaterDrops(x, y, game) {
 	for (var i = 0; i < 30; i++) {
@@ -1707,100 +1999,20 @@
 			waterDrops[i].update();
 		}
 	}
 }
-// Start the game
-initializeGame();
-/////////
-// Helper function to check if a tile is start or end
-var isStartOrEnd = function isStartOrEnd(tileType) {
-	return tileType === 'start' || tileType === 'end';
-};
-// Helper function to deep clone a level configuration
-var cloneLevelConfig = function cloneLevelConfig(level) {
-	var newTiles = [];
-	var i, j;
-	for (i = 0; i < level.tiles.length; i++) {
-		newTiles[i] = [];
-		for (j = 0; j < level.tiles[i].length; j++) {
-			newTiles[i][j] = level.tiles[i][j];
-		}
-	}
-	var newRotations = {};
-	for (var key in level.rotations) {
-		if (level.rotations.hasOwnProperty(key)) {
-			newRotations[key] = level.rotations[key];
-		}
-	}
-	var newFixedTiles = level.fixedTiles.slice();
-	return {
-		tiles: newTiles,
-		rotations: newRotations,
-		fixedTiles: newFixedTiles
-	};
-};
-// Level generator function
-var generateNextLevel = function generateNextLevel(existingLevels) {
-	var lastLevel = existingLevels[existingLevels.length - 1];
-	var newLevel = cloneLevelConfig(lastLevel);
-	var gridSize = 4;
-	var emptySpaces = [];
-	var x, y, i;
-	// Find empty spaces
-	for (y = 0; y < gridSize; y++) {
-		for (x = 0; x < gridSize; x++) {
-			if (!newLevel.tiles[y][x] && !isStartOrEnd(newLevel.tiles[y][x])) {
-				emptySpaces.push([x, y]);
-			}
-		}
-	}
-	// Add 1-2 new pipes
-	var numNewPipes = Math.min(1 + Math.floor(Math.random() * 2), emptySpaces.length);
-	var pipeTypes = ['straightPipeH', 'straightPipeV', 'cornerPipe'];
-	var spaceIndex, selectedSpace, newPipe;
-	for (i = 0; i < numNewPipes; i++) {
-		spaceIndex = Math.floor(Math.random() * emptySpaces.length);
-		selectedSpace = emptySpaces[spaceIndex];
-		emptySpaces.splice(spaceIndex, 1);
-		// Add new pipe
-		newPipe = pipeTypes[Math.floor(Math.random() * pipeTypes.length)];
-		newLevel.tiles[selectedSpace[1]][selectedSpace[0]] = newPipe;
-		// Add rotation for corner pipes
-		if (newPipe === 'cornerPipe') {
-			newLevel.rotations[selectedSpace[1] + ',' + selectedSpace[0]] = Math.random() < 0.5 ? 'left' : 'right';
-		}
-		// 70% chance to make it fixed
-		if (Math.random() < 0.7) {
-			newLevel.fixedTiles.push(selectedSpace[1] + ',' + selectedSpace[0]);
-		}
-	}
-	// Unfix one existing tile to increase difficulty
-	var removableFixed = newLevel.fixedTiles.filter(function (pos) {
-		var coords = pos.split(',');
-		return !isStartOrEnd(newLevel.tiles[coords[0]][coords[1]]);
-	});
-	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;
-};
-// Test data - existing levels
-var testLevels = [{
-	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']
-}, {
-	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(testLevels));
\ No newline at end of file
+// Test the level converter
+var testAsciiLevel = "\nS-C.\n.|..\n.C-E\n....\n";
+console.log("Testing ASCII to Level conversion:");
+var convertedLevel = stringToLevel(testAsciiLevel);
+if (typeof JSON !== 'undefined' && JSON.stringify) {
+	console.log("Converted Level:", JSON.stringify(convertedLevel, null, 2));
+} else {
+	console.log("JSON.stringify is not available.");
+}
+console.log("\nTesting Level to ASCII conversion:");
+var backToAscii = levelToString(convertedLevel);
+console.log("Back to ASCII:\n" + backToAscii);
+// Test generating a new level
+console.log("\nTesting level generation:");
+var generatedLevel = generateNextLevel([convertedLevel]);
+console.log("Generated Level ASCII:\n" + levelToString(generatedLevel));
\ No newline at end of file