===================================================================
--- original.js
+++ change.js
@@ -835,8 +835,72 @@
 ****/ 
 /**** 
 * Global level configurations
 ****/ 
+function _slicedToArray3(r, e) {
+	return _arrayWithHoles3(r) || _iterableToArrayLimit3(r, e) || _unsupportedIterableToArray3(r, e) || _nonIterableRest3();
+}
+function _nonIterableRest3() {
+	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 _unsupportedIterableToArray3(r, a) {
+	if (r) {
+		if ("string" == typeof r) {
+			return _arrayLikeToArray3(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) ? _arrayLikeToArray3(r, a) : void 0;
+	}
+}
+function _arrayLikeToArray3(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 _iterableToArrayLimit3(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 _arrayWithHoles3(r) {
+	if (Array.isArray(r)) {
+		return r;
+	}
+}
 function _slicedToArray2(r, e) {
 	return _arrayWithHoles2(r) || _iterableToArrayLimit2(r, e) || _unsupportedIterableToArray2(r, e) || _nonIterableRest2();
 }
 function _nonIterableRest2() {
@@ -900,44 +964,44 @@
 		return r;
 	}
 }
 var levelConfigs = {
-	1: {
-		"tiles": [["start", null, "straightPipeV", "cornerPipe"], [null, "straightPipeH", null, "straightPipeH"], [null, null, "straightPipeV", null], [null, null, null, "end"]],
-		"rotations": {
+	11: {
+		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,2", "0,3", "1,3", "3,3"]
+		fixedTiles: ["0,0", "0,1", "0,2", "0,3", "1,3", "3,3"]
 	},
-	4: {
-		tiles: [['start', 'straightPipeV', 'straightPipeV', 'cornerPipe'], [null, null, null, 'straightPipeH'], [null, null, 'straightPipeH', null], [null, null, null, 'end']],
+	2: {
+		tiles: [[null, "straightPipeH", "end", null], [null, "cornerPipe", "straightPipeH", null], [null, null, null, null], ["start", "straightPipeV", null, null]],
 		rotations: {
-			'0,3': 'right',
-			'3,3': 'left'
+			"0,2": "right",
+			"1,1": "left"
 		},
-		fixedTiles: ['0,0', '0,1', '0,2', '0,3', '1,3', '3,3']
+		fixedTiles: ["3,0", "3,1", "0,2", "1,2"]
 	},
-	2: {
-		tiles: [[null, 'straightPipeH', 'end', null], [null, 'cornerPipe', 'straightPipeH', null], [null, null, null, null], ['start', 'straightPipeV', null, null]],
+	3: {
+		tiles: [["cornerPipe", null, null, "straightPipeV"], ["cornerPipe", "end", null, "straightPipeH"], [null, null, null, null], [null, null, "straightPipeV", "start"]],
 		rotations: {
-			'0,2': 'right',
-			'1,1': 'left'
+			"0,0": "down",
+			"1,0": "up",
+			"1,1": "up",
+			"3,3": "up"
 		},
-		fixedTiles: ['3,0', '3,1', '0,2', '1,2']
+		fixedTiles: ["1,0", "1,1", "3,2", "3,3"]
 	},
-	3: {
-		tiles: [['cornerPipe', null, null, 'straightPipeV'], ['cornerPipe', 'end', null, 'straightPipeH'], [null, null, null, null], [null, null, 'straightPipeV', 'start']],
+	1: {
+		tiles: [["cornerPipe", null, null, "cornerPipe"], ["straightPipeH", "straightPipeV", "straightPipeV", "straightPipeH"], ["cornerPipe", "start", "end", "cornerPipe"], [null, null, null, null]],
 		rotations: {
-			'0,0': 'down',
-			// corner 1
-			'1,0': 'up',
-			// corner 2
-			'1,1': 'up',
-			// end
-			'3,3': 'up' // start
+			"0,0": "right",
+			"0,3": "up",
+			"2,0": "down",
+			"2,1": "up",
+			"2,3": "left"
 		},
-		fixedTiles: ['1,0', '1,1', '3,2', '3,3'] // Start, end, and 2 pipe fixed
+		fixedTiles: ["1,0", "1,3", "2,1", "2,2", "2,3"]
 	}
 };
 function _typeof(o) {
 	"@babel/helpers - typeof";
@@ -1337,67 +1401,107 @@
 			for (var j = 0; j < self.gridSize; j++) {
 				var tile = self.grid[i][j];
 				row.push(tile ? "".concat(tile.type, "(").concat(tile.rotation, ")") : 'empty');
 			}
-			log("Row", i + ":", row.join(' | '));
+			log("Row " + i + ":", row.join(' | '));
 		}
-		var startX = -1,
-			startY = -1;
-		for (var i = 0; i < self.gridSize; i++) {
-			for (var j = 0; j < self.gridSize; j++) {
-				if (self.grid[i][j].type === 'start') {
-					startX = i;
-					startY = j;
-					log("Start tile found at:", startX, startY);
-					break;
-				}
+		var visited = new SimpleSet();
+		var toCheck = [[startTile.gridX, startTile.gridY, getFlowDirection(startTile)]];
+		function getFlowDirection(tile) {
+			// Returns the direction the water flows out of this tile
+			var rotation = tile.normalizedRotation || tile.normalizeRotation(tile.pipeContainer.rotation);
+			switch (tile.type) {
+				case 'start':
+					return rotation;
+				// Start tile flows in the direction it points
+				case 'cornerPipe':
+					// Corner pipe changes flow direction by 90 degrees
+					return (rotation + Math.PI / 2) % (2 * Math.PI);
+				default:
+					return rotation;
 			}
-			if (startX !== -1) {
-				break;
+		}
+		function canAcceptFlowFromDirection(tile, incomingDirection) {
+			// incomingDirection is the direction the water is coming FROM
+			// Need to normalize it to match the tile's rotation
+			var normalizedIncoming = (incomingDirection + Math.PI) % (2 * Math.PI);
+			var tileRotation = tile.normalizedRotation || tile.normalizeRotation(tile.pipeContainer.rotation);
+			switch (tile.type) {
+				case 'start':
+					// Start tile only outputs, doesn't accept flow
+					return false;
+				case 'end':
+					// End tile only accepts flow from its rotated direction
+					var angle = (normalizedIncoming - tileRotation + 2 * Math.PI) % (2 * Math.PI);
+					return angle < 0.1;
+				// Only accept flow from the direction it points
+				case 'straightPipeV':
+					// Vertical pipe only accepts flow from top (π/2) or bottom (3π/2)
+					var angle = Math.abs(normalizedIncoming - Math.PI / 2) % (2 * Math.PI);
+					return angle < 0.1 || Math.abs(angle - Math.PI) < 0.1;
+				case 'straightPipeH':
+					// Horizontal pipe only accepts flow from left (π) or right (0)
+					var angle = normalizedIncoming % (2 * Math.PI);
+					return angle < 0.1 || Math.abs(angle - Math.PI) < 0.1;
+				case 'cornerPipe':
+					// Corner pipe accepts flow from two adjacent directions based on rotation
+					// It accepts flow from the direction it points and 90 degrees CCW from that
+					var angle = (normalizedIncoming - tileRotation + 2 * Math.PI) % (2 * Math.PI);
+					return angle < 0.1 || Math.abs(angle - Math.PI / 2) < 0.1;
+				default:
+					return false;
 			}
 		}
-		// Use array to track visited positions
-		var visited = [];
-		log("Starting path check from:", startX, startY);
-		// Start flowing down from start
-		var result = self.canReachEnd(startX, startY, visited);
-		log("Path check complete. Result:", result);
-		log("Visited positions:", visited);
-		log("=== Win Condition Check Complete ===");
-		return result;
-	};
-	self.canReachEnd = function (x, y, visited) {
-		log("Checking position:", x, y);
-		if (x < 0 || x >= self.gridSize || y < 0 || y >= self.gridSize) {
-			log("Position out of bounds");
-			return false;
-		}
-		var key = x + ',' + y;
-		if (visited.includes(key)) {
-			log("Position already visited:", key);
-			return false;
-		}
-		visited.push(key);
-		var tile = self.grid[x][y];
-		if (!tile || tile.type === 'empty') {
-			log("No tile or empty tile at position:", x, y);
-			return false;
-		}
-		if (tile.type === 'end') {
-			log("Found end tile!");
-			return true;
-		}
-		var normalizedRotation = tile.normalizeRotation(tile.pipeContainer.rotation);
-		log("Checking tile:", tile.type, "with normalized rotation:", normalizedRotation, "at position:", x, y);
-		var nextPositions = tile.getNextPositions(x, y, tile.type, normalizedRotation);
-		log("Next positions to check:", nextPositions);
-		for (var i = 0; i < nextPositions.length; i++) {
-			var nextPos = nextPositions[i];
-			log("Trying next position:", nextPos);
-			if (self.canReachEnd(nextPos[0], nextPos[1], visited)) {
-				return true;
+		while (toCheck.length > 0) {
+			var _toCheck$pop = toCheck.pop(),
+				_toCheck$pop2 = _slicedToArray3(_toCheck$pop, 3),
+				x = _toCheck$pop2[0],
+				y = _toCheck$pop2[1],
+				flowDirection = _toCheck$pop2[2];
+			var key = x + "," + y;
+			if (visited.has(key)) {
+				continue;
 			}
+			visited.add(key);
+			log("Checking position:", x, y);
+			var currentTile = self.grid[y][x];
+			if (!currentTile) {
+				continue;
+			}
+			var normalizedRotation = currentTile.normalizedRotation || currentTile.normalizeRotation(currentTile.pipeContainer.rotation);
+			log("Checking tile:", currentTile.type, "with normalized rotation:", normalizedRotation, "at position:", x, y);
+			// Get next positions based on current tile type and rotation
+			var nextPositions = currentTile.getNextPositions(x, y, currentTile.type, normalizedRotation);
+			log("Next positions to check:", nextPositions);
+			for (var i = 0; i < nextPositions.length; i++) {
+				var _nextPositions$i = _slicedToArray3(nextPositions[i], 2),
+					nextX = _nextPositions$i[0],
+					nextY = _nextPositions$i[1];
+				log("Trying next position:", nextPositions[i]);
+				if (nextX < 0 || nextX >= self.gridSize || nextY < 0 || nextY >= self.gridSize) {
+					continue;
+				}
+				var nextTile = self.grid[nextY][nextX];
+				if (!nextTile) {
+					continue;
+				}
+				// Calculate the direction the flow is coming from for the next tile
+				var incomingDirection = Math.atan2(nextY - y, nextX - x);
+				// Check if the next tile can accept flow from this direction
+				if (!canAcceptFlowFromDirection(nextTile, incomingDirection)) {
+					log("Tile at", nextX, nextY, "cannot accept flow from direction", incomingDirection);
+					continue;
+				}
+				if (nextTile.type === 'end') {
+					log("Found path to end!");
+					return true;
+				}
+				// Calculate the direction of flow out of the next tile
+				var nextFlowDirection = getFlowDirection(nextTile);
+				toCheck.push([nextX, nextY, nextFlowDirection]);
+			}
 		}
+		log("No valid path found");
 		return false;
 	};
 	return this;
 };
@@ -1441,249 +1545,8 @@
 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[x][y] = 'start';
-					fixedTiles.push(x + ',' + y);
-					startPos = [x, y];
-					break;
-				case 'E':
-					tiles[x][y] = 'end';
-					fixedTiles.push(x + ',' + y);
-					endPos = [x, y];
-					break;
-				case '|':
-					tiles[x][y] = 'straightPipeV';
-					break;
-				case '-':
-					tiles[x][y] = 'straightPipeH';
-					break;
-				case 'C':
-					tiles[x][y] = 'cornerPipe';
-					cornerPipes.push([x, y]);
-					break;
-				case 'F':
-					// Fixed straight pipe vertical
-					tiles[x][y] = 'straightPipeV';
-					fixedTiles.push(x + ',' + y);
-					break;
-				case '=':
-					// Fixed straight pipe horizontal
-					tiles[x][y] = 'straightPipeH';
-					fixedTiles.push(x + ',' + y);
-					break;
-				case '.':
-				case ' ':
-					tiles[x][y] = 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)) {
-				if (typeof JSON !== 'undefined') {
-					validConfig = JSON.parse(JSON.stringify(currentConfig));
-				} else {
-					console.error("JSON is not defined");
-					validConfig = null;
-				}
-				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[x][y];
-			var isFixed = level.fixedTiles && level.fixedTiles.includes(x + ',' + y);
-			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++) {
@@ -2025,23 +1888,5 @@
 		if (waterDrops[i].visible) {
 			waterDrops[i].update();
 		}
 	}
-}
-// Test the level converter
-console.log("Testing Level Converter with existing game levels:");
-// Test Level 1
-console.log("\nTesting Level 1:");
-var level1Config = levelConfigs[1];
-var asciiLevel = levelToString(level1Config);
-console.log("\nLevel 1 as ASCII:\n" + asciiLevel);
-// Convert back to level configuration
-console.log("\nConverting ASCII back to Level configuration:");
-var convertedLevel = stringToLevel(asciiLevel);
-console.log("\n=>", convertedLevel);
-var finalAscii = levelToString(convertedLevel);
-console.log(finalAscii);
-// Compare ASCII representations
-console.log("ASCII representations match:", asciiLevel === finalAscii);
-// New Levels:
-var newLevelStr = "C--S\nC--C\nC-.C\nCE.-";
-var newLevel = stringToLevel(newLevelStr);
\ No newline at end of file
+}
\ No newline at end of file