/**** 
* Plugins
****/ 
var tween = LK.import("@upit/tween.v1");
var storage = LK.import("@upit/storage.v1");

/**** 
* Classes
****/ 
var Ball = Container.expand(function () {
	var self = Container.call(this);
	var ballGraphics = self.attachAsset('ball', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.velocityX = 8;
	self.velocityY = -12;
	self.radius = 14;
	self.maxSpeed = 16;
	self.update = function () {
		// Don't move ball until it's launched
		if (!ballLaunched) return;
		// Limit ball speed to prevent it from becoming too fast
		var currentSpeed = Math.sqrt(self.velocityX * self.velocityX + self.velocityY * self.velocityY);
		if (currentSpeed > self.maxSpeed) {
			var ratio = self.maxSpeed / currentSpeed;
			self.velocityX *= ratio;
			self.velocityY *= ratio;
		}
		self.x += self.velocityX;
		self.y += self.velocityY;
		// Wall collision detection
		if (self.x - self.radius <= 0 || self.x + self.radius >= 2048) {
			self.velocityX = -self.velocityX;
			if (self.x - self.radius <= 0) self.x = self.radius;
			if (self.x + self.radius >= 2048) self.x = 2048 - self.radius;
			LK.getSound('hitWall').play();
		}
		// Top wall collision
		if (self.y - self.radius <= 0) {
			self.velocityY = -self.velocityY;
			self.y = self.radius;
			LK.getSound('hitWall').play();
		}
	};
	return self;
});
var Brick = Container.expand(function (brickType) {
	var self = Container.call(this);
	var assetName = brickType || 'brick';
	var brickGraphics = self.attachAsset(assetName, {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.width = 150;
	self.height = 45;
	self.destroyed = false;
	return self;
});
var LevelMenu = Container.expand(function () {
	var self = Container.call(this);
	self.currentPage = 0;
	self.levelsPerPage = 15;
	self.totalLevels = 30;
	self.unlockedLevel = storage.unlockedLevel || 1;
	var levelButtons = [];
	var leftArrow = null;
	var rightArrow = null;
	var pageText = null;
	self.createMenu = function () {
		// Remove existing buttons before creating new ones
		if (self.languageButton) {
			self.removeChild(self.languageButton);
			self.languageButton.destroy();
			self.languageButton = null;
		}
		if (self.settingsButton) {
			self.removeChild(self.settingsButton);
			self.settingsButton.destroy();
			self.settingsButton = null;
		}
		if (levelButtons && levelButtons.length > 0) {
			for (var i = 0; i < levelButtons.length; i++) {
				if (levelButtons[i]) {
					self.removeChild(levelButtons[i]);
					levelButtons[i].destroy();
				}
			}
			levelButtons = [];
		}
		if (leftArrow) {
			self.removeChild(leftArrow);
			leftArrow.destroy();
			leftArrow = null;
		}
		if (rightArrow) {
			self.removeChild(rightArrow);
			rightArrow.destroy();
			rightArrow = null;
		}
		if (pageText) {
			self.removeChild(pageText);
			pageText.destroy();
			pageText = null;
		}
		// Create language switching button at the top
		var languageButton = new Container();
		var languageBg = languageButton.attachAsset('brick', {
			anchorX: 0.5,
			anchorY: 0.5,
			scaleX: 0.8,
			scaleY: 0.8
		});
		languageBg.tint = 0x3498db; // Blue color for language button
		var languageText = new Text2(getText('language'), {
			size: 50,
			fill: 0xFFFFFF
		});
		languageText.anchor.set(0.5, 0.5);
		languageButton.addChild(languageText);
		languageButton.x = 1024; // Center of screen
		languageButton.y = 300; // Top of screen
		languageButton.setText = function (text) {
			languageText.setText(text);
		};
		languageButton.down = function (x, y, obj) {
			self.showLanguageMenu();
		};
		self.addChild(languageButton);
		self.languageButton = languageButton;
		// Create settings button to the left of Level 1
		var settingsButton = new Container();
		var settingsBg = settingsButton.attachAsset('brick', {
			anchorX: 0.5,
			anchorY: 0.5,
			scaleX: 0.8,
			scaleY: 0.8
		});
		settingsBg.tint = 0x95a5a6; // Gray color for settings
		var settingsText = new Text2(getText('settings'), {
			size: 45,
			fill: 0xFFFFFF
		});
		settingsText.anchor.set(0.5, 0.5);
		settingsButton.addChild(settingsText);
		settingsButton.x = 200; // Position to the left of first level button with spacing
		settingsButton.y = 800; // Same Y as first row of level buttons
		settingsButton.setText = function (text) {
			settingsText.setText(text);
		};
		settingsButton.down = function (x, y, obj) {
			self.showSettingsMenu();
		};
		self.addChild(settingsButton);
		self.settingsButton = settingsButton;
		// Create level buttons in 3 rows of 5
		for (var i = 0; i < self.levelsPerPage; i++) {
			var row = Math.floor(i / 5);
			var col = i % 5;
			var button = new Container();
			var buttonBg = button.attachAsset('brick', {
				anchorX: 0.5,
				anchorY: 0.5
			});
			var levelNum = new Text2('1', {
				size: 60,
				fill: 0xFFFFFF
			});
			levelNum.anchor.set(0.5, 0.5);
			button.addChild(levelNum);
			// Calculate level number to determine if it's in the second page (16-30)
			var levelNumber = self.currentPage * self.levelsPerPage + i + 1;
			var extraSpacing = 0;
			if (levelNumber >= 16 && levelNumber <= 30) {
				// Add extra spacing for levels 16-30 to separate them from other buttons
				extraSpacing = 150;
			}
			button.x = 1024 + (col - 2) * (300 + extraSpacing);
			button.y = 800 + row * (200 + extraSpacing);
			button.levelIndex = i;
			button.levelText = levelNum;
			button.bg = buttonBg;
			button.down = function (x, y, obj) {
				var levelToStart = self.currentPage * self.levelsPerPage + this.levelIndex + 1;
				if (levelToStart <= self.unlockedLevel) {
					self.startLevel(levelToStart);
				}
			};
			levelButtons.push(button);
			self.addChild(button);
		}
		// Create navigation arrows
		leftArrow = new Container();
		var leftBg = leftArrow.attachAsset('brick', {
			anchorX: 0.5,
			anchorY: 0.5,
			scaleX: 0.8,
			scaleY: 0.8
		});
		var leftText = new Text2('<', {
			size: 120,
			fill: 0xFFFFFF
		});
		leftText.anchor.set(0.5, 0.5);
		leftArrow.addChild(leftText);
		leftArrow.x = 300;
		leftArrow.y = 1000;
		leftArrow.down = function () {
			if (self.currentPage > 0) {
				self.currentPage--;
				self.updatePage();
			}
		};
		self.addChild(leftArrow);
		rightArrow = new Container();
		var rightBg = rightArrow.attachAsset('brick', {
			anchorX: 0.5,
			anchorY: 0.5,
			scaleX: 0.8,
			scaleY: 0.8
		});
		var rightText = new Text2('>', {
			size: 120,
			fill: 0xFFFFFF
		});
		rightText.anchor.set(0.5, 0.5);
		rightArrow.addChild(rightText);
		rightArrow.x = 1748;
		rightArrow.y = 1000;
		rightArrow.down = function () {
			var maxPages = Math.ceil(self.totalLevels / self.levelsPerPage);
			if (self.currentPage < maxPages - 1) {
				self.currentPage++;
				self.updatePage();
			}
		};
		self.addChild(rightArrow);
		// Create page indicator
		pageText = new Text2('Page 1 / 2', {
			size: 80,
			fill: 0xFFFFFF
		});
		pageText.anchor.set(0.5, 0.5);
		pageText.x = 1024;
		pageText.y = 1400;
		self.addChild(pageText);
		self.updatePage();
	};
	self.updatePage = function () {
		var maxPages = Math.ceil(self.totalLevels / self.levelsPerPage);
		for (var i = 0; i < levelButtons.length; i++) {
			var levelNum = self.currentPage * self.levelsPerPage + i + 1;
			var button = levelButtons[i];
			if (levelNum <= self.totalLevels) {
				button.levelText.setText(levelNum.toString());
				button.visible = true;
				// Set button color based on unlock status
				if (levelNum <= self.unlockedLevel) {
					button.bg.tint = 0x00ff00; // Green for unlocked
				} else {
					button.bg.tint = 0xff0000; // Red for locked
				}
			} else {
				button.visible = false;
			}
		}
		// Update page text
		pageText.setText(getText('page') + ' ' + (self.currentPage + 1) + ' / ' + maxPages);
		self.pageText = pageText;
		// Update arrow visibility
		leftArrow.visible = self.currentPage > 0;
		rightArrow.visible = self.currentPage < maxPages - 1;
	};
	self.showLanguageMenu = function () {
		// Create language selection overlay
		var overlay = new Container();
		var overlayBg = overlay.attachAsset('brick', {
			anchorX: 0.5,
			anchorY: 0.5,
			scaleX: 20,
			scaleY: 20
		});
		overlayBg.tint = 0x2c3e50;
		overlayBg.alpha = 0.9;
		overlay.x = 1024;
		overlay.y = 1366;
		// Turkish button
		var turkishBtn = new Container();
		var turkishBg = turkishBtn.attachAsset('brick', {
			anchorX: 0.5,
			anchorY: 0.5,
			scaleX: 1.2,
			scaleY: 1.0
		});
		turkishBg.tint = currentLanguage === 'tr' ? 0x27ae60 : 0x7f8c8d;
		var turkishText = new Text2(getText('turkish'), {
			size: 70,
			fill: 0xFFFFFF
		});
		turkishText.anchor.set(0.5, 0.5);
		turkishBtn.addChild(turkishText);
		turkishBtn.x = 0;
		turkishBtn.y = -150;
		turkishBtn.down = function () {
			switchLanguage('tr');
			self.removeChild(overlay);
			overlay.destroy();
		};
		overlay.addChild(turkishBtn);
		// English button
		var englishBtn = new Container();
		var englishBg = englishBtn.attachAsset('brick', {
			anchorX: 0.5,
			anchorY: 0.5,
			scaleX: 1.2,
			scaleY: 1.0
		});
		englishBg.tint = currentLanguage === 'en' ? 0x27ae60 : 0x7f8c8d;
		var englishText = new Text2(getText('english'), {
			size: 70,
			fill: 0xFFFFFF
		});
		englishText.anchor.set(0.5, 0.5);
		englishBtn.addChild(englishText);
		englishBtn.x = 0;
		englishBtn.y = 50;
		englishBtn.down = function () {
			switchLanguage('en');
			self.removeChild(overlay);
			overlay.destroy();
		};
		overlay.addChild(englishBtn);
		// Back button
		var backBtn = new Container();
		var backBg = backBtn.attachAsset('brick', {
			anchorX: 0.5,
			anchorY: 0.5,
			scaleX: 1.2,
			scaleY: 1.0
		});
		backBg.tint = 0x95a5a6; // Gray color for back button
		var backText = new Text2('←', {
			size: 80,
			fill: 0xFFFFFF
		});
		backText.anchor.set(0.5, 0.5);
		backBtn.addChild(backText);
		backBtn.x = 0;
		backBtn.y = 400;
		backBtn.down = function () {
			self.removeChild(overlay);
			overlay.destroy();
		};
		overlay.addChild(backBtn);
		self.addChild(overlay);
	};
	self.showSettingsMenu = function () {
		// Create settings overlay
		var overlay = new Container();
		var overlayBg = overlay.attachAsset('brick', {
			anchorX: 0.5,
			anchorY: 0.5,
			scaleX: 20,
			scaleY: 20
		});
		overlayBg.tint = 0x2c3e50;
		overlayBg.alpha = 0.9;
		overlay.x = 1024;
		overlay.y = 1366;
		// Language button in settings
		var languageBtn = new Container();
		var languageBg = languageBtn.attachAsset('brick', {
			anchorX: 0.5,
			anchorY: 0.5,
			scaleX: 1.2,
			scaleY: 1.0
		});
		languageBg.tint = 0x3498db; // Blue color for language button
		var languageText = new Text2(getText('language'), {
			size: 70,
			fill: 0xFFFFFF
		});
		languageText.anchor.set(0.5, 0.5);
		languageBtn.addChild(languageText);
		languageBtn.x = 0;
		languageBtn.y = -200;
		languageBtn.down = function () {
			self.removeChild(overlay);
			overlay.destroy();
			self.showLanguageMenu();
		};
		overlay.addChild(languageBtn);
		// Admin menu button
		var adminBtn = new Container();
		var adminBg = adminBtn.attachAsset('brick', {
			anchorX: 0.5,
			anchorY: 0.5,
			scaleX: 1.2,
			scaleY: 1.0
		});
		adminBg.tint = 0x9b59b6; // Purple color for admin
		var adminText = new Text2('Admin', {
			size: 70,
			fill: 0xFFFFFF
		});
		adminText.anchor.set(0.5, 0.5);
		adminBtn.addChild(adminText);
		adminBtn.x = 0;
		adminBtn.y = -100;
		adminBtn.down = function () {
			self.removeChild(overlay);
			overlay.destroy();
			self.showAdminMenu();
		};
		overlay.addChild(adminBtn);
		// Close button
		var closeBtn = new Container();
		var closeBg = closeBtn.attachAsset('brick', {
			anchorX: 0.5,
			anchorY: 0.5,
			scaleX: 1.2,
			scaleY: 1.0
		});
		closeBg.tint = 0xe74c3c;
		var closeText = new Text2('X', {
			size: 70,
			fill: 0xFFFFFF
		});
		closeText.anchor.set(0.5, 0.5);
		closeBtn.addChild(closeText);
		closeBtn.x = 0;
		closeBtn.y = 0;
		closeBtn.down = function () {
			self.removeChild(overlay);
			overlay.destroy();
		};
		overlay.addChild(closeBtn);
		// Back button
		var backBtn = new Container();
		var backBg = backBtn.attachAsset('brick', {
			anchorX: 0.5,
			anchorY: 0.5,
			scaleX: 1.2,
			scaleY: 1.0
		});
		backBg.tint = 0x95a5a6; // Gray color for back button
		var backText = new Text2('←', {
			size: 80,
			fill: 0xFFFFFF
		});
		backText.anchor.set(0.5, 0.5);
		backBtn.addChild(backText);
		backBtn.x = 0;
		backBtn.y = 500;
		backBtn.down = function () {
			self.removeChild(overlay);
			overlay.destroy();
		};
		overlay.addChild(backBtn);
		self.addChild(overlay);
	};
	self.showAdminMenu = function () {
		// Admin password tracker
		var enteredPassword = '';
		var correctPassword = '2010';
		// Create admin overlay
		var overlay = new Container();
		var overlayBg = overlay.attachAsset('brick', {
			anchorX: 0.5,
			anchorY: 0.5,
			scaleX: 20,
			scaleY: 20
		});
		overlayBg.tint = 0x2c3e50;
		overlayBg.alpha = 0.9;
		overlay.x = 1024;
		overlay.y = 1366;
		// Admin title
		var adminTitle = new Text2('Admin Panel', {
			size: 100,
			fill: 0xFFFFFF
		});
		adminTitle.anchor.set(0.5, 0.5);
		adminTitle.x = 0;
		adminTitle.y = -500;
		overlay.addChild(adminTitle);
		// Instructions
		var instructText = new Text2('Şifreyi girin: 2010', {
			size: 60,
			fill: 0xFFFFFF
		});
		instructText.anchor.set(0.5, 0.5);
		instructText.x = 0;
		instructText.y = -400;
		overlay.addChild(instructText);
		// Password display
		var passwordDisplay = new Text2('****', {
			size: 80,
			fill: 0x00ff00
		});
		passwordDisplay.anchor.set(0.5, 0.5);
		passwordDisplay.x = 0;
		passwordDisplay.y = -320;
		overlay.addChild(passwordDisplay);
		// Create phone-style keypad buttons (1-9, 0)
		var keypadButtons = [];
		var keypadNumbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0];
		for (var i = 0; i < 10; i++) {
			var row = Math.floor(i / 3);
			var col = i % 3;
			var number = keypadNumbers[i];
			// Special positioning for 0
			if (number === 0) {
				row = 3;
				col = 1;
			}
			var keyBtn = new Container();
			var keyBg = keyBtn.attachAsset('brick', {
				anchorX: 0.5,
				anchorY: 0.5,
				scaleX: 1.0,
				scaleY: 1.0
			});
			keyBg.tint = 0x3498db; // Blue for keypad
			var keyText = new Text2(number.toString(), {
				size: 70,
				fill: 0xFFFFFF
			});
			keyText.anchor.set(0.5, 0.5);
			keyBtn.addChild(keyText);
			keyBtn.x = (col - 1) * 200;
			keyBtn.y = -200 + row * 120;
			keyBtn.number = number;
			keyBtn.bg = keyBg;
			keyBtn.down = function () {
				// Add number to password
				enteredPassword += this.number.toString();
				// Update display with asterisks
				var displayText = '';
				for (var k = 0; k < enteredPassword.length; k++) {
					displayText += '*';
				}
				passwordDisplay.setText(displayText);
				// Check if password is complete
				if (enteredPassword.length === 4) {
					if (enteredPassword === correctPassword) {
						// Correct password - unlock all levels
						storage.unlockedLevel = 30;
						passwordDisplay.setText('Doğru şifre!');
						passwordDisplay.tint = 0x00ff00;
						// Show success animation
						LK.effects.flashScreen(0x00ff00, 1000);
						// Auto close after 2 seconds
						LK.setTimeout(function () {
							self.removeChild(overlay);
							overlay.destroy();
							// Refresh level menu to show unlocked levels
							self.unlockedLevel = 30;
							self.updatePage();
						}, 2000);
					} else {
						// Wrong password - reset
						enteredPassword = '';
						passwordDisplay.setText('Yanlış şifre!');
						passwordDisplay.tint = 0xff0000;
						// Flash red to indicate error
						LK.effects.flashScreen(0xff0000, 500);
						// Reset display after 1 second
						LK.setTimeout(function () {
							passwordDisplay.setText('****');
							passwordDisplay.tint = 0x00ff00;
						}, 1000);
					}
				}
			};
			keypadButtons.push(keyBtn);
			overlay.addChild(keyBtn);
		}
		// Clear button
		var clearBtn = new Container();
		var clearBg = clearBtn.attachAsset('brick', {
			anchorX: 0.5,
			anchorY: 0.5,
			scaleX: 1.2,
			scaleY: 1.0
		});
		clearBg.tint = 0xe74c3c; // Red for clear
		var clearText = new Text2('C', {
			size: 70,
			fill: 0xFFFFFF
		});
		clearText.anchor.set(0.5, 0.5);
		clearBtn.addChild(clearText);
		clearBtn.x = -200;
		clearBtn.y = 160;
		clearBtn.down = function () {
			enteredPassword = '';
			passwordDisplay.setText('****');
			passwordDisplay.tint = 0x00ff00;
		};
		overlay.addChild(clearBtn);
		// Back button
		var backBtn = new Container();
		var backBg = backBtn.attachAsset('brick', {
			anchorX: 0.5,
			anchorY: 0.5,
			scaleX: 1.2,
			scaleY: 1.0
		});
		backBg.tint = 0x95a5a6; // Gray color for back button
		var backText = new Text2('←', {
			size: 80,
			fill: 0xFFFFFF
		});
		backText.anchor.set(0.5, 0.5);
		backBtn.addChild(backText);
		backBtn.x = 200;
		backBtn.y = 160;
		backBtn.down = function () {
			self.removeChild(overlay);
			overlay.destroy();
		};
		overlay.addChild(backBtn);
		self.addChild(overlay);
	};
	self.startLevel = function (levelNumber) {
		currentLevel = levelNumber;
		self.destroy();
		startGame();
	};
	return self;
});
var Paddle = Container.expand(function () {
	var self = Container.call(this);
	var paddleGraphics = self.attachAsset('paddle', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.width = 260;
	self.height = 24;
	return self;
});

/**** 
* Initialize Game
****/ 
var game = new LK.Game({
	backgroundColor: 0x2c3e50
});

/**** 
* Game Code
****/ 
// Language system
var currentLanguage = storage.language || 'tr';
var texts = {
	tr: {
		settings: 'Ayarlar',
		language: 'Dil',
		english: 'İngilizce',
		turkish: 'Türkçe',
		score: 'Skor',
		lives: 'Can',
		page: 'Sayfa'
	},
	en: {
		settings: 'Settings',
		language: 'Language',
		english: 'English',
		turkish: 'Turkish',
		score: 'Score',
		lives: 'Lives',
		page: 'Page'
	}
};
function getText(key) {
	return texts[currentLanguage][key] || key;
}
function switchLanguage(newLanguage) {
	currentLanguage = newLanguage;
	storage.language = newLanguage;
	// Update all UI text elements
	updateLanguageTexts();
}
function updateLanguageTexts() {
	if (levelMenu && levelMenu.languageButton) {
		levelMenu.languageButton.setText(getText('language'));
	}
	if (levelMenu && levelMenu.settingsButton) {
		levelMenu.settingsButton.setText(getText('settings'));
	}
	if (scoreTxt) {
		scoreTxt.setText(getText('score') + ': ' + LK.getScore());
	}
	if (livesTxt) {
		livesTxt.setText(getText('lives') + ':');
	}
	if (levelMenu && levelMenu.pageText) {
		var maxPages = Math.ceil(levelMenu.totalLevels / levelMenu.levelsPerPage);
		levelMenu.pageText.setText(getText('page') + ' ' + (levelMenu.currentPage + 1) + ' / ' + maxPages);
	}
}
var currentLevel = 1;
var gameStarted = false;
var ballLaunched = false;
var levelMenu = null;
var lives = 3;
var heartIcons = [];
var winTarget = null;
// Initialize level menu first
levelMenu = game.addChild(new LevelMenu());
levelMenu.createMenu();
var paddle = null;
var ball = null;
var bricks = [];
var scoreTxt = null;
var livesTxt = null;
function startGame() {
	gameStarted = true;
	ballLaunched = false;
	// Remove old paddle if it exists
	if (paddle) {
		paddle.destroy();
		paddle = null;
	}
	// Create paddle
	paddle = game.addChild(new Paddle());
	paddle.x = 2048 / 2;
	paddle.y = 2600;
	// Remove old ball if it exists
	if (ball) {
		ball.destroy();
		ball = null;
	}
	// Create ball
	ball = game.addChild(new Ball());
	ball.x = 2048 / 2;
	ball.y = 2400;
	// Remove old win target if it exists
	if (winTarget) {
		winTarget.destroy();
		winTarget = null;
	}
	// Create win target zone at the top
	winTarget = LK.getAsset('brickGreen', {
		anchorX: 0.5,
		anchorY: 0.5,
		scaleX: 9.1,
		scaleY: 0.5
	});
	winTarget.x = 2048 / 2;
	winTarget.y = 50;
	winTarget.tint = 0x00ff00; // Bright green color
	game.addChild(winTarget);
	// Remove old bricks if they exist
	for (var oldBrick = 0; oldBrick < bricks.length; oldBrick++) {
		if (bricks[oldBrick]) {
			bricks[oldBrick].destroy();
		}
	}
	// Create bricks based on current level
	bricks = [];
	var brickColors = ['brick', 'brickBlue', 'brickGreen', 'brickYellow', 'brickPurple'];
	if (currentLevel === 1) {
		// Level 1: Standard rectangular layout
		var rows = 8;
		var cols = 18;
		var brickSpacingX = 165;
		var brickSpacingY = 60;
		var startX = (2048 - (cols - 1) * brickSpacingX) / 2;
		var startY = 200;
		for (var row = 0; row < rows; row++) {
			for (var col = 0; col < cols; col++) {
				var colorIndex = row % brickColors.length;
				var brick = new Brick(brickColors[colorIndex]);
				brick.x = startX + col * brickSpacingX;
				brick.y = startY + row * brickSpacingY;
				bricks.push(brick);
				game.addChild(brick);
			}
		}
	} else if (currentLevel === 2) {
		// Level 2: Pyramid pattern like original Breakout
		var maxCols = 16;
		var brickSpacingX = 165;
		var brickSpacingY = 60;
		var startY = 200;
		for (var row = 0; row < 8; row++) {
			var colsInRow = maxCols - row;
			var startX = (2048 - (colsInRow - 1) * brickSpacingX) / 2;
			for (var col = 0; col < colsInRow; col++) {
				var colorIndex = row % brickColors.length;
				var brick = new Brick(brickColors[colorIndex]);
				brick.x = startX + col * brickSpacingX;
				brick.y = startY + row * brickSpacingY;
				bricks.push(brick);
				game.addChild(brick);
			}
		}
	} else if (currentLevel === 3) {
		// Level 3: Diamond pattern inspired by classic Breakout
		var rows = 8;
		var cols = 14;
		var brickSpacingX = 165;
		var brickSpacingY = 60;
		var centerX = 2048 / 2;
		var startY = 200;
		for (var row = 0; row < rows; row++) {
			// Create diamond shape: wider in middle, narrower at top and bottom
			var bricksInRow;
			if (row <= 3) {
				bricksInRow = 4 + row * 2; // Growing: 4, 6, 8, 10
			} else {
				bricksInRow = 4 + (7 - row) * 2; // Shrinking: 8, 6, 4, 2
			}
			var startX = centerX - (bricksInRow - 1) * brickSpacingX / 2;
			for (var col = 0; col < bricksInRow; col++) {
				// Add some strategic gaps for challenge
				var skipBrick = false;
				// Create gaps in the middle rows for more interesting gameplay
				if (row >= 2 && row <= 5) {
					if (col === Math.floor(bricksInRow / 3) || col === Math.floor(bricksInRow * 2 / 3)) {
						skipBrick = true;
					}
				}
				if (!skipBrick) {
					// Use different colors for different sections
					var colorIndex;
					if (row <= 1) {
						colorIndex = 0; // Red at top
					} else if (row <= 3) {
						colorIndex = 1; // Blue
					} else if (row <= 5) {
						colorIndex = 2; // Green in middle
					} else {
						colorIndex = 3; // Yellow at bottom
					}
					var brick = new Brick(brickColors[colorIndex]);
					brick.x = startX + col * brickSpacingX;
					brick.y = startY + row * brickSpacingY;
					bricks.push(brick);
					game.addChild(brick);
				}
			}
		}
	} else if (currentLevel === 4) {
		// Level 4: Classic Breakout fortress with walls and corridors
		var rows = 10;
		var cols = 16;
		var brickSpacingX = 165;
		var brickSpacingY = 55;
		var startX = (2048 - (cols - 1) * brickSpacingX) / 2;
		var startY = 180;
		for (var row = 0; row < rows; row++) {
			for (var col = 0; col < cols; col++) {
				var skipBrick = false;
				// Create fortress-like structure with strategic openings
				if (row >= 2 && row <= 7) {
					// Create vertical corridors every 4 columns
					if (col % 4 === 1 || col % 4 === 2) {
						// Leave gaps in middle rows for corridors
						if (row >= 4 && row <= 5) {
							skipBrick = true;
						}
					}
					// Create horizontal opening in the middle
					if (row === 5 && col >= 6 && col <= 9) {
						skipBrick = true;
					}
					// Create defensive walls on sides
					if ((col <= 2 || col >= cols - 3) && row >= 1 && row <= 8) {
						// Solid side walls with occasional gaps
						if (row === 3 || row === 6) {
							if (col === 1 || col === cols - 2) {
								skipBrick = true; // Small openings in walls
							}
						}
					}
				}
				if (!skipBrick) {
					// Color scheme like classic Breakout - different colors for different rows
					var colorIndex;
					if (row <= 1) {
						colorIndex = 0; // Red at top (hardest to reach)
					} else if (row <= 3) {
						colorIndex = 4; // Purple for fortress walls
					} else if (row <= 5) {
						colorIndex = 1; // Blue for middle section
					} else if (row <= 7) {
						colorIndex = 2; // Green for lower middle
					} else {
						colorIndex = 3; // Yellow at bottom (easiest to reach)
					}
					var brick = new Brick(brickColors[colorIndex]);
					brick.x = startX + col * brickSpacingX;
					brick.y = startY + row * brickSpacingY;
					bricks.push(brick);
					game.addChild(brick);
				}
			}
		}
	} else if (currentLevel === 5) {
		// Level 5: Classic Breakout castle with towers and defensive structure
		var rows = 12;
		var cols = 15;
		var brickSpacingX = 170;
		var brickSpacingY = 50;
		var startX = (2048 - (cols - 1) * brickSpacingX) / 2;
		var startY = 150;
		for (var row = 0; row < rows; row++) {
			for (var col = 0; col < cols; col++) {
				var skipBrick = false;
				// Create castle-like structure with towers
				// Tower positions at columns 1, 7, 13 (left, center, right towers)
				var isTowerCol = col === 1 || col === 7 || col === 13;
				var isWallCol = col >= 3 && col <= 5 || col >= 9 && col <= 11;
				// Build tall towers
				if (isTowerCol) {
					// Towers are solid except for strategic openings
					if (row === 5 || row === 8) {
						// Small windows in towers
						skipBrick = true;
					}
				} else if (isWallCol) {
					// Connecting walls between towers
					if (row >= 4 && row <= 6) {
						// Leave gaps in middle section of walls for strategy
						if (row === 5) {
							skipBrick = true;
						}
					} else if (row >= 9) {
						// Lower walls are mostly solid
						skipBrick = false;
					} else {
						// Upper sections have some gaps
						if (row <= 2 && (col === 4 || col === 10)) {
							skipBrick = true;
						}
					}
				} else {
					// Areas between structures
					if (row >= 3 && row <= 8) {
						// Create strategic openings and passages
						if ((col === 0 || col === 14) && row >= 6) {
							// Side passages
							skipBrick = false;
						} else if (col >= 2 && col <= 6 && row >= 6 || col >= 8 && col <= 12 && row >= 6) {
							// Lower defensive walls
							skipBrick = false;
						} else {
							// Open areas for ball movement
							skipBrick = true;
						}
					} else if (row >= 9) {
						// Foundation level - mostly solid
						if (col % 3 === 1) {
							// Small gaps in foundation
							skipBrick = true;
						}
					}
				}
				if (!skipBrick) {
					// Color scheme inspired by castle architecture
					var colorIndex;
					if (row <= 2) {
						colorIndex = 0; // Red at top (castle peaks)
					} else if (isTowerCol) {
						if (row <= 6) {
							colorIndex = 4; // Purple for tower walls
						} else {
							colorIndex = 2; // Green for tower base
						}
					} else if (isWallCol) {
						colorIndex = 1; // Blue for connecting walls
					} else if (row >= 9) {
						colorIndex = 3; // Yellow for foundation
					} else {
						colorIndex = 2; // Green for general structure
					}
					var brick = new Brick(brickColors[colorIndex]);
					brick.x = startX + col * brickSpacingX;
					brick.y = startY + row * brickSpacingY;
					bricks.push(brick);
					game.addChild(brick);
				}
			}
		}
	} else if (currentLevel === 6) {
		// Level 6: Classic Breakout-inspired spiral maze pattern
		var rows = 11;
		var cols = 17;
		var brickSpacingX = 160;
		var brickSpacingY = 55;
		var startX = (2048 - (cols - 1) * brickSpacingX) / 2;
		var startY = 170;
		var centerX = Math.floor(cols / 2);
		var centerY = Math.floor(rows / 2);
		for (var row = 0; row < rows; row++) {
			for (var col = 0; col < cols; col++) {
				var skipBrick = false;
				// Calculate distance from center for spiral effect
				var dx = col - centerX;
				var dy = row - centerY;
				var distance = Math.sqrt(dx * dx + dy * dy);
				// Create spiral pattern inspired by classic arcade design
				var angle = Math.atan2(dy, dx);
				var spiralRadius = distance + angle * 1.5;
				// Create the main spiral structure
				if (distance <= 1.5) {
					// Keep center mostly open with small obstacles
					if (row === centerY && col === centerX) {
						skipBrick = true; // Complete center open
					} else if (distance <= 1.2) {
						skipBrick = Math.random() > 0.3; // Some random gaps near center
					}
				} else if (distance <= 6) {
					// Create spiral arms with strategic gaps
					var spiralArm = Math.floor((angle + Math.PI) / (Math.PI / 3)); // 6 arms
					var armOffset = spiralRadius % 2;
					if (armOffset < 0.8) {
						// Create gaps in spiral for ball passages
						if ((row + col) % 3 === 0) {
							skipBrick = true;
						}
					} else if (armOffset > 1.5) {
						// Solid sections of spiral
						skipBrick = false;
					} else {
						// Transition areas - some gaps
						skipBrick = (row + col) % 4 === 0;
					}
				} else {
					// Outer perimeter - create defensive walls with strategic openings
					if (row === 0 || row === rows - 1) {
						// Top and bottom walls with gaps
						if (col % 4 === 1 || col % 4 === 2) {
							skipBrick = true;
						}
					} else if (col === 0 || col === cols - 1) {
						// Side walls with gaps
						if (row % 3 === 1) {
							skipBrick = true;
						}
					} else if (row === 1 || row === rows - 2) {
						// Inner perimeter walls
						if (col % 5 === 2 || col % 5 === 3) {
							skipBrick = true;
						}
					} else {
						// Outer field area - mostly open with some obstacles
						skipBrick = true;
						if ((row + col) % 6 === 0) {
							skipBrick = false; // Scattered obstacles
						}
					}
				}
				if (!skipBrick) {
					// Color scheme based on distance from center (classic arcade style)
					var colorIndex;
					if (distance <= 1.5) {
						colorIndex = 0; // Red for center core
					} else if (distance <= 3) {
						colorIndex = 4; // Purple for inner spiral
					} else if (distance <= 4.5) {
						colorIndex = 1; // Blue for middle spiral
					} else if (distance <= 6) {
						colorIndex = 2; // Green for outer spiral
					} else {
						colorIndex = 3; // Yellow for perimeter
					}
					var brick = new Brick(brickColors[colorIndex]);
					brick.x = startX + col * brickSpacingX;
					brick.y = startY + row * brickSpacingY;
					bricks.push(brick);
					game.addChild(brick);
				}
			}
		}
	} else if (currentLevel === 7) {
		// Level 7: Classic Breakout-inspired honeycomb hexagonal pattern
		var rows = 10;
		var cols = 15;
		var brickSpacingX = 170;
		var brickSpacingY = 65;
		var startX = (2048 - (cols - 1) * brickSpacingX) / 2;
		var startY = 180;
		var centerX = Math.floor(cols / 2);
		var centerY = Math.floor(rows / 2);
		for (var row = 0; row < rows; row++) {
			for (var col = 0; col < cols; col++) {
				var skipBrick = false;
				// Calculate distance from center for hexagonal pattern
				var dx = col - centerX;
				var dy = row - centerY;
				var distance = Math.sqrt(dx * dx + dy * dy);
				// Offset alternating rows for honeycomb effect
				var offsetX = row % 2 * brickSpacingX * 0.5;
				// Create honeycomb hexagonal structure
				if (distance <= 2) {
					// Center hexagon - solid core with small opening
					if (row === centerY && col === centerX) {
						skipBrick = true; // Center opening
					} else if (distance <= 1.2) {
						skipBrick = false; // Inner hex ring
					}
				} else if (distance <= 4) {
					// Middle hexagonal rings with strategic gaps
					var hexRing = Math.floor(distance);
					var hexAngle = Math.atan2(dy, dx);
					var hexSector = Math.floor((hexAngle + Math.PI) / (Math.PI / 3)); // 6 sectors
					// Create hexagonal pattern with gaps at vertices
					if (hexRing === 2) {
						// First outer ring - gaps at hex vertices
						if (hexSector % 2 === 0 && (Math.abs(dx) === 2 || Math.abs(dy) === 2)) {
							skipBrick = true;
						}
					} else if (hexRing === 3) {
						// Second outer ring - alternating pattern
						if ((row + col) % 3 === 0) {
							skipBrick = true;
						}
					}
				} else if (distance <= 6) {
					// Outer defensive hex structure
					var outerHexAngle = Math.atan2(dy, dx);
					var outerSector = Math.floor((outerHexAngle + Math.PI) / (Math.PI / 3));
					// Create outer hexagonal walls with strategic openings
					if (distance >= 5.5) {
						// Outer perimeter - gaps for ball entry
						if (outerSector === 1 || outerSector === 4) {
							// Top and bottom entry points
							if (row === 1 && col >= centerX - 1 && col <= centerX + 1) {
								skipBrick = true;
							} else if (row === rows - 2 && col >= centerX - 1 && col <= centerX + 1) {
								skipBrick = true;
							}
						} else if (outerSector === 0 || outerSector === 3) {
							// Side entry points
							if (col === 2 || col === cols - 3) {
								if (row >= centerY - 1 && row <= centerY + 1) {
									skipBrick = true;
								}
							}
						}
					} else {
						// Mid-outer ring - honeycomb cells
						var cellX = Math.floor((col - centerX + 6) / 3);
						var cellY = Math.floor((row - centerY + 5) / 3);
						if ((cellX + cellY) % 2 === 0) {
							// Create honeycomb cell walls
							if ((col - centerX) % 3 === 1 || (row - centerY) % 3 === 1) {
								skipBrick = true;
							}
						}
					}
				} else {
					// Outermost area - scattered defensive structures
					if (row === 0 || row === rows - 1 || col === 0 || col === cols - 1) {
						// Perimeter walls with regular gaps
						if ((row + col) % 4 === 0) {
							skipBrick = true;
						}
					} else {
						// Scattered outer obstacles
						if ((row + col) % 7 === 0) {
							skipBrick = false;
						} else {
							skipBrick = true;
						}
					}
				}
				if (!skipBrick) {
					// Color scheme based on hexagonal structure
					var colorIndex;
					if (distance <= 1.5) {
						colorIndex = 0; // Red for center core
					} else if (distance <= 2.5) {
						colorIndex = 4; // Purple for inner hex
					} else if (distance <= 4) {
						colorIndex = 1; // Blue for middle hex rings
					} else if (distance <= 5.5) {
						colorIndex = 2; // Green for outer hex structure
					} else {
						colorIndex = 3; // Yellow for perimeter
					}
					var brick = new Brick(brickColors[colorIndex]);
					brick.x = startX + col * brickSpacingX + offsetX;
					brick.y = startY + row * brickSpacingY;
					bricks.push(brick);
					game.addChild(brick);
				}
			}
		}
	} else if (currentLevel === 8) {
		// Level 8: Classic Breakout-inspired cross/plus pattern with strategic chambers
		var rows = 12;
		var cols = 16;
		var brickSpacingX = 160;
		var brickSpacingY = 55;
		var startX = (2048 - (cols - 1) * brickSpacingX) / 2;
		var startY = 170;
		var centerX = Math.floor(cols / 2);
		var centerY = Math.floor(rows / 2);
		for (var row = 0; row < rows; row++) {
			for (var col = 0; col < cols; col++) {
				var skipBrick = false;
				// Calculate position relative to center
				var dx = Math.abs(col - centerX);
				var dy = Math.abs(row - centerY);
				// Create cross/plus pattern inspired by classic arcade design
				// Vertical arm of the cross
				var isVerticalArm = dx <= 2;
				// Horizontal arm of the cross
				var isHorizontalArm = dy <= 2;
				// Main cross structure
				if (isVerticalArm || isHorizontalArm) {
					// Center intersection - keep open for strategy
					if (dx <= 1 && dy <= 1) {
						skipBrick = true; // Central crossing
					} else if (isVerticalArm && !isHorizontalArm) {
						// Vertical arm - create strategic gaps
						if (row % 3 === 1) {
							skipBrick = true; // Regular gaps in vertical arm
						}
					} else if (isHorizontalArm && !isVerticalArm) {
						// Horizontal arm - create strategic gaps
						if (col % 3 === 1) {
							skipBrick = true; // Regular gaps in horizontal arm
						}
					} else {
						// Intersection areas - mostly solid with some gaps
						if ((row + col) % 4 === 0) {
							skipBrick = true;
						}
					}
				} else {
					// Outer chambers in the four quadrants
					var quadrantX = col < centerX ? 0 : 1; // Left=0, Right=1
					var quadrantY = row < centerY ? 0 : 1; // Top=0, Bottom=1
					// Create defensive structures in each quadrant
					if (dx >= 4 && dy >= 4) {
						// Corner fortresses - solid defensive structures
						if (quadrantX === 0 && quadrantY === 0 || quadrantX === 1 && quadrantY === 1) {
							// Top-left and bottom-right corners - fortress pattern
							if (dx >= 6 || dy >= 6) {
								// Outer fortress walls
								if ((row + col) % 3 !== 0) {
									skipBrick = false;
								} else {
									skipBrick = true; // Small gaps for ball entry
								}
							} else {
								// Inner fortress area - mostly open with obstacles
								if ((row + col) % 5 === 0) {
									skipBrick = false; // Scattered obstacles
								} else {
									skipBrick = true;
								}
							}
						} else {
							// Top-right and bottom-left corners - maze pattern
							if (dx >= 6 || dy >= 6) {
								// Outer maze walls with passages
								if (row % 2 === 0 && col % 3 === 0 || col % 2 === 0 && row % 3 === 0) {
									skipBrick = false;
								} else {
									skipBrick = true;
								}
							} else {
								// Inner maze area
								if ((row + col) % 4 === 2) {
									skipBrick = false;
								} else {
									skipBrick = true;
								}
							}
						}
					} else {
						// Transition zones between cross and corners
						if (dx === 3 || dy === 3) {
							// Boundary walls with strategic openings
							if ((row + col) % 4 === 0) {
								skipBrick = true; // Regular openings
							}
						} else {
							// Open areas for ball movement
							skipBrick = true;
							// Add some scattered obstacles
							if ((row + col) % 8 === 0) {
								skipBrick = false;
							}
						}
					}
				}
				if (!skipBrick) {
					// Color scheme based on cross structure
					var colorIndex;
					if (dx <= 1 && dy <= 1) {
						colorIndex = 0; // Red for center intersection
					} else if (isVerticalArm || isHorizontalArm) {
						if (dx <= 2 && dy <= 2) {
							colorIndex = 4; // Purple for cross intersection areas
						} else if (isVerticalArm) {
							colorIndex = 1; // Blue for vertical arm
						} else {
							colorIndex = 2; // Green for horizontal arm
						}
					} else if (dx >= 6 || dy >= 6) {
						colorIndex = 3; // Yellow for outer fortresses
					} else {
						colorIndex = 0; // Red for transition areas
					}
					var brick = new Brick(brickColors[colorIndex]);
					brick.x = startX + col * brickSpacingX;
					brick.y = startY + row * brickSpacingY;
					bricks.push(brick);
					game.addChild(brick);
				}
			}
		}
	} else if (currentLevel === 9) {
		// Level 9: Classic Breakout-inspired target/bullseye pattern with concentric rings
		var rows = 11;
		var cols = 17;
		var brickSpacingX = 160;
		var brickSpacingY = 55;
		var startX = (2048 - (cols - 1) * brickSpacingX) / 2;
		var startY = 170;
		var centerX = Math.floor(cols / 2);
		var centerY = Math.floor(rows / 2);
		for (var row = 0; row < rows; row++) {
			for (var col = 0; col < cols; col++) {
				var skipBrick = false;
				// Calculate distance from center for concentric rings
				var dx = col - centerX;
				var dy = row - centerY;
				var distance = Math.sqrt(dx * dx + dy * dy);
				// Create bullseye/target pattern with concentric rings
				if (distance <= 1.5) {
					// Center bullseye - keep open for strategic targeting
					skipBrick = true;
				} else if (distance <= 2.5) {
					// First inner ring - solid with small gaps
					if ((row + col) % 6 === 0) {
						skipBrick = true; // Small targeting gaps
					}
				} else if (distance <= 3.5) {
					// Second ring - alternating pattern for visual distinction
					if ((row + col) % 3 === 1) {
						skipBrick = true; // Regular gaps for ball movement
					}
				} else if (distance <= 4.5) {
					// Third ring - mostly solid defensive ring
					if ((row + col) % 4 === 0) {
						skipBrick = true; // Strategic openings
					}
				} else if (distance <= 5.5) {
					// Fourth ring - outer defensive perimeter
					if ((row + col) % 5 === 0) {
						skipBrick = true; // Larger gaps for ball entry
					}
				} else if (distance <= 6.5) {
					// Fifth ring - sparse outer ring
					if ((row + col) % 2 === 0) {
						skipBrick = true; // Many gaps for easier access
					}
				} else {
					// Outer fortification - corner defensive structures
					// Create corner bastions inspired by classic arcade design
					var cornerDistance = Math.min(Math.min(dx, cols - 1 - dx), Math.min(dy, rows - 1 - dy));
					if (cornerDistance <= 1) {
						// Corner walls with strategic openings
						if ((row === 0 || row === rows - 1) && col % 4 === 1) {
							skipBrick = true; // Top/bottom wall gaps
						} else if ((col === 0 || col === cols - 1) && row % 3 === 1) {
							skipBrick = true; // Side wall gaps
						}
					} else {
						// Open areas between corners and target
						skipBrick = true;
						// Add scattered obstacles for challenge
						if ((row + col) % 7 === 0) {
							skipBrick = false; // Random obstacles
						}
					}
				}
				if (!skipBrick) {
					// Color scheme based on target rings - classic arcade bullseye colors
					var colorIndex;
					if (distance <= 2.5) {
						colorIndex = 0; // Red for center target ring (highest value)
					} else if (distance <= 3.5) {
						colorIndex = 4; // Purple for second ring
					} else if (distance <= 4.5) {
						colorIndex = 1; // Blue for third ring
					} else if (distance <= 5.5) {
						colorIndex = 2; // Green for fourth ring
					} else if (distance <= 6.5) {
						colorIndex = 3; // Yellow for outer ring
					} else {
						colorIndex = 0; // Red for corner fortifications
					}
					var brick = new Brick(brickColors[colorIndex]);
					brick.x = startX + col * brickSpacingX;
					brick.y = startY + row * brickSpacingY;
					bricks.push(brick);
					game.addChild(brick);
				}
			}
		}
	} else if (currentLevel === 10) {
		// Level 10: Classic Breakout-inspired infinity/figure-8 pattern
		var rows = 12;
		var cols = 18;
		var brickSpacingX = 155;
		var brickSpacingY = 55;
		var startX = (2048 - (cols - 1) * brickSpacingX) / 2;
		var startY = 160;
		var centerX = Math.floor(cols / 2);
		var centerY = Math.floor(rows / 2);
		for (var row = 0; row < rows; row++) {
			for (var col = 0; col < cols; col++) {
				var skipBrick = false;
				// Calculate position relative to center for infinity pattern
				var dx = col - centerX;
				var dy = row - centerY;
				var distance = Math.sqrt(dx * dx + dy * dy);
				// Create figure-8/infinity symbol pattern
				// Upper loop center
				var upperLoopCenterY = centerY - 3;
				var upperDx = col - centerX;
				var upperDy = row - upperLoopCenterY;
				var upperDistance = Math.sqrt(upperDx * upperDx + upperDy * upperDy);
				// Lower loop center
				var lowerLoopCenterY = centerY + 3;
				var lowerDx = col - centerX;
				var lowerDy = row - lowerLoopCenterY;
				var lowerDistance = Math.sqrt(lowerDx * lowerDx + lowerDy * lowerDy);
				// Central crossing area
				if (Math.abs(dx) <= 1 && Math.abs(dy) <= 1) {
					// Center intersection - keep mostly open
					skipBrick = true;
				} else if (upperDistance <= 3.5 && row <= centerY) {
					// Upper loop of infinity symbol
					if (upperDistance >= 1.5 && upperDistance <= 3.5) {
						// Create loop structure with strategic gaps
						var upperAngle = Math.atan2(upperDy, upperDx);
						var angleSector = Math.floor((upperAngle + Math.PI) / (Math.PI / 4)); // 8 sectors
						if (angleSector % 3 === 0) {
							skipBrick = true; // Gaps for ball movement
						}
					} else if (upperDistance < 1.5) {
						// Inner area of upper loop - mostly open
						skipBrick = true;
					}
				} else if (lowerDistance <= 3.5 && row >= centerY) {
					// Lower loop of infinity symbol
					if (lowerDistance >= 1.5 && lowerDistance <= 3.5) {
						// Create loop structure with strategic gaps
						var lowerAngle = Math.atan2(lowerDy, lowerDx);
						var angleSector = Math.floor((lowerAngle + Math.PI) / (Math.PI / 4)); // 8 sectors
						if (angleSector % 3 === 0) {
							skipBrick = true; // Gaps for ball movement
						}
					} else if (lowerDistance < 1.5) {
						// Inner area of lower loop - mostly open
						skipBrick = true;
					}
				} else if (Math.abs(dy) <= 2 && Math.abs(dx) >= 2 && Math.abs(dx) <= 4) {
					// Connecting bridge between loops
					if (Math.abs(dx) === 3 && Math.abs(dy) <= 1) {
						// Narrow bridge connection
						skipBrick = false;
					} else {
						// Side areas of bridge - some gaps
						if ((row + col) % 3 === 0) {
							skipBrick = true;
						}
					}
				} else if (distance <= 7) {
					// Outer defensive perimeter around infinity pattern
					if (distance >= 6) {
						// Outer ring - walls with strategic openings
						if (row === 0 || row === rows - 1) {
							// Top and bottom walls
							if (col % 5 === 0 || col % 5 === 1) {
								skipBrick = true; // Entry gaps
							}
						} else if (col === 0 || col === cols - 1) {
							// Side walls
							if (row % 4 === 0) {
								skipBrick = true; // Side entry gaps
							}
						}
					} else {
						// Mid-range defensive structures
						if ((row + col) % 4 === 0) {
							skipBrick = true; // Strategic openings
						}
					}
				} else {
					// Outermost corners - scattered defensive obstacles
					if ((row + col) % 6 === 0) {
						skipBrick = false; // Corner obstacles
					} else {
						skipBrick = true;
					}
				}
				if (!skipBrick) {
					// Color scheme based on infinity pattern structure
					var colorIndex;
					if (Math.abs(dx) <= 1 && Math.abs(dy) <= 1) {
						colorIndex = 0; // Red for center crossing
					} else if (upperDistance <= 3.5 && row <= centerY || lowerDistance <= 3.5 && row >= centerY) {
						// Color loops differently for visual distinction
						if (row <= centerY) {
							colorIndex = 4; // Purple for upper loop
						} else {
							colorIndex = 1; // Blue for lower loop
						}
					} else if (Math.abs(dy) <= 2 && Math.abs(dx) >= 2 && Math.abs(dx) <= 4) {
						colorIndex = 2; // Green for connecting bridge
					} else if (distance <= 6) {
						colorIndex = 3; // Yellow for mid-range defenses
					} else {
						colorIndex = 0; // Red for outer obstacles
					}
					var brick = new Brick(brickColors[colorIndex]);
					brick.x = startX + col * brickSpacingX;
					brick.y = startY + row * brickSpacingY;
					bricks.push(brick);
					game.addChild(brick);
				}
			}
		}
	} else {
		// Default pattern for other levels
		var rows = Math.min(8, 5 + Math.floor(currentLevel / 5));
		var cols = 18;
		var brickSpacingX = 165;
		var brickSpacingY = 60;
		var startX = (2048 - (cols - 1) * brickSpacingX) / 2;
		var startY = 200;
		for (var row = 0; row < rows; row++) {
			for (var col = 0; col < cols; col++) {
				var colorIndex = row % brickColors.length;
				var brick = new Brick(brickColors[colorIndex]);
				brick.x = startX + col * brickSpacingX;
				brick.y = startY + row * brickSpacingY;
				bricks.push(brick);
				game.addChild(brick);
			}
		}
	}
	// Remove old UI elements if they exist
	if (scoreTxt) {
		scoreTxt.destroy();
		scoreTxt = null;
	}
	if (livesTxt) {
		livesTxt.destroy();
		livesTxt = null;
	}
	// Create UI elements
	scoreTxt = new Text2(getText('score') + ': 0', {
		size: 80,
		fill: 0xFFFFFF
	});
	scoreTxt.anchor.set(0, 0);
	LK.gui.topRight.addChild(scoreTxt);
	livesTxt = new Text2(getText('lives') + ':', {
		size: 80,
		fill: 0xFFFFFF
	});
	livesTxt.anchor.set(0, 0);
	livesTxt.x = -600;
	LK.gui.topRight.addChild(livesTxt);
	// Clear existing heart icons
	for (var hi = 0; hi < heartIcons.length; hi++) {
		if (heartIcons[hi]) heartIcons[hi].destroy();
	}
	heartIcons = [];
	// Add heart icons based on remaining lives
	for (var h = 0; h < lives; h++) {
		var heartIcon = LK.getAsset('heart', {
			anchorX: 0.5,
			anchorY: 0.5
		});
		heartIcon.x = -350 + h * 80;
		heartIcon.y = 40;
		LK.gui.topRight.addChild(heartIcon);
		heartIcons.push(heartIcon);
	}
	// Reset game state
	lives = 3;
	if (currentLevel === 1) {
		LK.setScore(0);
	}
}
var dragNode = null;
var lastBallY = 0;
function handleMove(x, y, obj) {
	if (!gameStarted) return;
	if (dragNode) {
		// Launch ball on first paddle movement
		if (!ballLaunched) {
			ballLaunched = true;
		}
		dragNode.x = x;
		// Keep paddle within screen bounds
		if (dragNode.x < dragNode.width / 2) {
			dragNode.x = dragNode.width / 2;
		}
		if (dragNode.x > 2048 - dragNode.width / 2) {
			dragNode.x = 2048 - dragNode.width / 2;
		}
	}
}
game.move = handleMove;
game.down = function (x, y, obj) {
	if (!gameStarted) return;
	// Launch ball on first touch
	if (!ballLaunched) {
		ballLaunched = true;
	}
	dragNode = paddle;
	handleMove(x, y, obj);
};
game.up = function (x, y, obj) {
	if (!gameStarted) return;
	dragNode = null;
};
function resetBall() {
	if (!ball) return;
	ball.x = 2048 / 2;
	ball.y = 2400;
	// Start with consistent angle like original Breakout
	ball.velocityX = (Math.random() > 0.5 ? 1 : -1) * 6;
	ball.velocityY = -12;
	ballLaunched = false;
}
function checkPaddleCollision() {
	if (!paddle || !ball) return;
	var paddleLeft = paddle.x - paddle.width / 2;
	var paddleRight = paddle.x + paddle.width / 2;
	var paddleTop = paddle.y - paddle.height / 2;
	var paddleBottom = paddle.y + paddle.height / 2;
	if (ball.x + ball.radius >= paddleLeft && ball.x - ball.radius <= paddleRight && ball.y + ball.radius >= paddleTop && ball.y - ball.radius <= paddleBottom && ball.velocityY > 0) {
		// Calculate hit position relative to paddle center (-1 to 1)
		var hitPos = (ball.x - paddle.x) / (paddle.width / 2);
		// Adjust ball velocity based on hit position with more realistic physics
		var speed = Math.sqrt(ball.velocityX * ball.velocityX + ball.velocityY * ball.velocityY);
		var angle = hitPos * Math.PI * 0.25; // Max 45 degree angle
		ball.velocityX = Math.sin(angle) * speed;
		ball.velocityY = -Math.cos(angle) * speed;
		// Position ball above paddle
		ball.y = paddleTop - ball.radius;
		LK.getSound('hitPaddle').play();
	}
}
function checkBrickCollisions() {
	if (!ball) return;
	for (var i = bricks.length - 1; i >= 0; i--) {
		var brick = bricks[i];
		if (brick.destroyed) continue;
		var brickLeft = brick.x - brick.width / 2;
		var brickRight = brick.x + brick.width / 2;
		var brickTop = brick.y - brick.height / 2;
		var brickBottom = brick.y + brick.height / 2;
		if (ball.x + ball.radius >= brickLeft && ball.x - ball.radius <= brickRight && ball.y + ball.radius >= brickTop && ball.y - ball.radius <= brickBottom) {
			// Determine collision side
			var overlapLeft = ball.x + ball.radius - brickLeft;
			var overlapRight = brickRight - (ball.x - ball.radius);
			var overlapTop = ball.y + ball.radius - brickTop;
			var overlapBottom = brickBottom - (ball.y - ball.radius);
			var minOverlap = Math.min(overlapLeft, overlapRight, overlapTop, overlapBottom);
			if (minOverlap === overlapTop || minOverlap === overlapBottom) {
				ball.velocityY = -ball.velocityY;
			} else {
				ball.velocityX = -ball.velocityX;
			}
			brick.destroyed = true;
			brick.destroy();
			bricks.splice(i, 1);
			LK.setScore(LK.getScore() + 10);
			scoreTxt.setText(getText('score') + ': ' + LK.getScore());
			LK.getSound('hitBrick').play();
			// No automatic level progression when bricks are destroyed
			// Level progression now happens when ball reaches top
			break;
		}
	}
}
game.update = function () {
	if (!gameStarted || !ball) return;
	// Check if ball fell below paddle
	if (lastBallY <= 2732 && ball.y > 2732) {
		lives--;
		livesTxt.setText(getText('lives') + ':');
		// Remove a heart icon when life is lost
		if (heartIcons.length > 0) {
			var heartToRemove = heartIcons.pop();
			heartToRemove.destroy();
		}
		if (lives <= 0) {
			LK.showGameOver();
		} else {
			resetBall();
		}
	}
	checkPaddleCollision();
	checkBrickCollisions();
	// Check if ball hits the win target zone
	if (ball.intersects(winTarget)) {
		// Stop the game immediately
		gameStarted = false;
		ballLaunched = false;
		// Level completed by reaching top - unlock next level
		var unlockedLevel = storage.unlockedLevel || 1;
		if (currentLevel >= unlockedLevel && currentLevel < 30) {
			storage.unlockedLevel = currentLevel + 1;
		}
		// Create victory animation with multiple effects
		LK.effects.flashScreen(0x00ff00, 1000); // Green flash for victory
		// Animate the win target with a scaling effect
		tween(winTarget, {
			scaleX: 12,
			scaleY: 2,
			alpha: 0.3
		}, {
			duration: 1000,
			easing: tween.bounceOut
		});
		// Create victory overlay
		var victoryOverlay = new Container();
		var overlayBg = victoryOverlay.attachAsset('brick', {
			anchorX: 0.5,
			anchorY: 0.5,
			scaleX: 20,
			scaleY: 20
		});
		overlayBg.tint = 0x2c3e50;
		overlayBg.alpha = 0.9;
		victoryOverlay.x = 1024;
		victoryOverlay.y = 1366;
		game.addChild(victoryOverlay);
		// Victory title with animation
		var victoryTitle = new Text2('KAZANDIN!', {
			size: 150,
			fill: 0x00ff00
		});
		victoryTitle.anchor.set(0.5, 0.5);
		victoryTitle.x = 0;
		victoryTitle.y = -200;
		victoryTitle.alpha = 0;
		victoryOverlay.addChild(victoryTitle);
		// Animate victory title
		tween(victoryTitle, {
			alpha: 1,
			scaleX: 1.2,
			scaleY: 1.2
		}, {
			duration: 800,
			easing: tween.bounceOut
		});
		// Level completion text
		var levelText = new Text2('Seviye ' + currentLevel + ' Tamamlandı!', {
			size: 80,
			fill: 0xFFFFFF
		});
		levelText.anchor.set(0.5, 0.5);
		levelText.x = 0;
		levelText.y = -50;
		levelText.alpha = 0;
		victoryOverlay.addChild(levelText);
		// Animate level text with delay
		LK.setTimeout(function () {
			tween(levelText, {
				alpha: 1
			}, {
				duration: 500,
				easing: tween.easeOut
			});
		}, 400);
		// Check if all levels completed
		if (currentLevel >= 30) {
			// Final victory - show you win
			LK.setTimeout(function () {
				LK.showYouWin();
			}, 2000);
		} else {
			// Create next level button
			var nextLevelBtn = new Container();
			var nextBg = nextLevelBtn.attachAsset('brick', {
				anchorX: 0.5,
				anchorY: 0.5,
				scaleX: 1.5,
				scaleY: 1.0
			});
			nextBg.tint = 0x27ae60; // Green for next level
			var nextText = new Text2('Sonraki Seviye', {
				size: 60,
				fill: 0xFFFFFF
			});
			nextText.anchor.set(0.5, 0.5);
			nextLevelBtn.addChild(nextText);
			nextLevelBtn.x = -200;
			nextLevelBtn.y = 150;
			nextLevelBtn.alpha = 0;
			nextLevelBtn.down = function () {
				// Progress to next level
				currentLevel++;
				// Clean up victory overlay
				victoryOverlay.destroy();
				// Restart game with next level
				startGame();
			};
			victoryOverlay.addChild(nextLevelBtn);
			// Create menu button
			var menuBtn = new Container();
			var menuBg = menuBtn.attachAsset('brick', {
				anchorX: 0.5,
				anchorY: 0.5,
				scaleX: 1.5,
				scaleY: 1.0
			});
			menuBg.tint = 0x3498db; // Blue for menu
			var menuText = new Text2('Menüye Dön', {
				size: 60,
				fill: 0xFFFFFF
			});
			menuText.anchor.set(0.5, 0.5);
			menuBtn.addChild(menuText);
			menuBtn.x = 200;
			menuBtn.y = 150;
			menuBtn.alpha = 0;
			menuBtn.down = function () {
				// Return to menu
				gameStarted = false;
				// Clean up all game elements
				if (paddle) {
					paddle.destroy();
					paddle = null;
				}
				if (ball) {
					ball.destroy();
					ball = null;
				}
				if (winTarget) {
					winTarget.destroy();
					winTarget = null;
				}
				for (var j = 0; j < bricks.length; j++) {
					if (bricks[j]) bricks[j].destroy();
				}
				bricks = [];
				// Clear UI elements
				if (scoreTxt) {
					scoreTxt.destroy();
					scoreTxt = null;
				}
				if (livesTxt) {
					livesTxt.destroy();
					livesTxt = null;
				}
				for (var hi = 0; hi < heartIcons.length; hi++) {
					if (heartIcons[hi]) heartIcons[hi].destroy();
				}
				heartIcons = [];
				LK.gui.topRight.removeChildren();
				// Clean up victory overlay
				victoryOverlay.destroy();
				// Show level menu
				levelMenu = game.addChild(new LevelMenu());
				levelMenu.createMenu();
			};
			victoryOverlay.addChild(menuBtn);
			// Animate buttons with delay
			LK.setTimeout(function () {
				tween(nextLevelBtn, {
					alpha: 1
				}, {
					duration: 500,
					easing: tween.easeOut
				});
				tween(menuBtn, {
					alpha: 1
				}, {
					duration: 500,
					easing: tween.easeOut
				});
			}, 800);
		}
		return;
	}
	// Check if all bricks are destroyed for level progression (alternative win condition)
	var activeBricks = 0;
	for (var b = 0; b < bricks.length; b++) {
		if (!bricks[b].destroyed) {
			activeBricks++;
		}
	}
	if (activeBricks === 0) {
		// Level completed - unlock next level
		var unlockedLevel = storage.unlockedLevel || 1;
		if (currentLevel >= unlockedLevel && currentLevel < 30) {
			storage.unlockedLevel = currentLevel + 1;
		}
		// Add level completion visual effect
		LK.effects.flashScreen(0x00ff00, 500); // Green flash for level completion
		// Check if all levels completed
		if (currentLevel >= 30) {
			LK.showYouWin();
		} else {
			// Show level transition message
			var levelCompleteText = new Text2('Level ' + currentLevel + ' Complete!', {
				size: 120,
				fill: 0xFFFFFF
			});
			levelCompleteText.anchor.set(0.5, 0.5);
			levelCompleteText.x = 1024;
			levelCompleteText.y = 1366;
			game.addChild(levelCompleteText);
			// Auto-progress to next level
			currentLevel++;
			// Show next level message
			var nextLevelText = new Text2('Starting Level ' + currentLevel, {
				size: 100,
				fill: 0xFFFF00
			});
			nextLevelText.anchor.set(0.5, 0.5);
			nextLevelText.x = 1024;
			nextLevelText.y = 1500;
			game.addChild(nextLevelText);
			// Clear current game elements after delay
			LK.setTimeout(function () {
				// Remove transition texts
				levelCompleteText.destroy();
				nextLevelText.destroy();
				if (paddle) {
					paddle.destroy();
					paddle = null;
				}
				if (ball) {
					ball.destroy();
					ball = null;
				}
				for (var j = 0; j < bricks.length; j++) {
					if (bricks[j]) bricks[j].destroy();
				}
				bricks = [];
				// Clear UI elements properly
				if (scoreTxt) {
					scoreTxt.destroy();
					scoreTxt = null;
				}
				if (livesTxt) {
					livesTxt.destroy();
					livesTxt = null;
				}
				// Clear heart icons
				for (var hi = 0; hi < heartIcons.length; hi++) {
					if (heartIcons[hi]) heartIcons[hi].destroy();
				}
				heartIcons = [];
				// Clear all GUI elements to prevent orphaned references
				LK.gui.topRight.removeChildren();
				// Start next level
				startGame();
			}, 1500);
			return;
		}
	}
	lastBallY = ball.y;
};

===================================================================
--- original.js
+++ change.js
@@ -459,12 +459,11 @@
 		overlay.addChild(backBtn);
 		self.addChild(overlay);
 	};
 	self.showAdminMenu = function () {
-		// Admin sequence tracker
-		var adminSequence = [];
-		var correctSequence = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30];
-		var currentIndex = 0;
+		// Admin password tracker
+		var enteredPassword = '';
+		var correctPassword = '2010';
 		// Create admin overlay
 		var overlay = new Container();
 		var overlayBg = overlay.attachAsset('brick', {
 			anchorX: 0.5,
@@ -485,64 +484,71 @@
 		adminTitle.x = 0;
 		adminTitle.y = -500;
 		overlay.addChild(adminTitle);
 		// Instructions
-		var instructText = new Text2('Doğru sırayla 1-30 arası sayılara dokun', {
+		var instructText = new Text2('Şifreyi girin: 2010', {
 			size: 60,
 			fill: 0xFFFFFF
 		});
 		instructText.anchor.set(0.5, 0.5);
 		instructText.x = 0;
 		instructText.y = -400;
 		overlay.addChild(instructText);
-		// Status text
-		var statusText = new Text2('Beklenen: 1', {
-			size: 70,
+		// Password display
+		var passwordDisplay = new Text2('****', {
+			size: 80,
 			fill: 0x00ff00
 		});
-		statusText.anchor.set(0.5, 0.5);
-		statusText.x = 0;
-		statusText.y = -320;
-		overlay.addChild(statusText);
-		// Create number buttons in 5x6 grid
-		var numberButtons = [];
-		for (var i = 0; i < 30; i++) {
-			var row = Math.floor(i / 5);
-			var col = i % 5;
-			var number = i + 1;
-			var numBtn = new Container();
-			var numBg = numBtn.attachAsset('brick', {
+		passwordDisplay.anchor.set(0.5, 0.5);
+		passwordDisplay.x = 0;
+		passwordDisplay.y = -320;
+		overlay.addChild(passwordDisplay);
+		// Create phone-style keypad buttons (1-9, 0)
+		var keypadButtons = [];
+		var keypadNumbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0];
+		for (var i = 0; i < 10; i++) {
+			var row = Math.floor(i / 3);
+			var col = i % 3;
+			var number = keypadNumbers[i];
+			// Special positioning for 0
+			if (number === 0) {
+				row = 3;
+				col = 1;
+			}
+			var keyBtn = new Container();
+			var keyBg = keyBtn.attachAsset('brick', {
 				anchorX: 0.5,
 				anchorY: 0.5,
-				scaleX: 0.8,
-				scaleY: 0.8
+				scaleX: 1.0,
+				scaleY: 1.0
 			});
-			numBg.tint = 0x3498db; // Blue for unclicked
-			var numText = new Text2(number.toString(), {
-				size: 50,
+			keyBg.tint = 0x3498db; // Blue for keypad
+			var keyText = new Text2(number.toString(), {
+				size: 70,
 				fill: 0xFFFFFF
 			});
-			numText.anchor.set(0.5, 0.5);
-			numBtn.addChild(numText);
-			numBtn.x = (col - 2) * 200;
-			numBtn.y = -200 + row * 100;
-			numBtn.number = number;
-			numBtn.bg = numBg;
-			numBtn.clicked = false;
-			numBtn.down = function () {
-				if (this.clicked) return;
-				if (this.number === correctSequence[currentIndex]) {
-					// Correct number
-					this.bg.tint = 0x27ae60; // Green for correct
-					this.clicked = true;
-					currentIndex++;
-					if (currentIndex < correctSequence.length) {
-						statusText.setText('Beklenen: ' + correctSequence[currentIndex]);
-					} else {
-						// Sequence completed - unlock all levels
+			keyText.anchor.set(0.5, 0.5);
+			keyBtn.addChild(keyText);
+			keyBtn.x = (col - 1) * 200;
+			keyBtn.y = -200 + row * 120;
+			keyBtn.number = number;
+			keyBtn.bg = keyBg;
+			keyBtn.down = function () {
+				// Add number to password
+				enteredPassword += this.number.toString();
+				// Update display with asterisks
+				var displayText = '';
+				for (var k = 0; k < enteredPassword.length; k++) {
+					displayText += '*';
+				}
+				passwordDisplay.setText(displayText);
+				// Check if password is complete
+				if (enteredPassword.length === 4) {
+					if (enteredPassword === correctPassword) {
+						// Correct password - unlock all levels
 						storage.unlockedLevel = 30;
-						statusText.setText('Tüm seviyeler açıldı!');
-						statusText.tint = 0x00ff00;
+						passwordDisplay.setText('Doğru şifre!');
+						passwordDisplay.tint = 0x00ff00;
 						// Show success animation
 						LK.effects.flashScreen(0x00ff00, 1000);
 						// Auto close after 2 seconds
 						LK.setTimeout(function () {
@@ -551,25 +557,49 @@
 							// Refresh level menu to show unlocked levels
 							self.unlockedLevel = 30;
 							self.updatePage();
 						}, 2000);
+					} else {
+						// Wrong password - reset
+						enteredPassword = '';
+						passwordDisplay.setText('Yanlış şifre!');
+						passwordDisplay.tint = 0xff0000;
+						// Flash red to indicate error
+						LK.effects.flashScreen(0xff0000, 500);
+						// Reset display after 1 second
+						LK.setTimeout(function () {
+							passwordDisplay.setText('****');
+							passwordDisplay.tint = 0x00ff00;
+						}, 1000);
 					}
-				} else {
-					// Wrong number - reset sequence
-					for (var j = 0; j < numberButtons.length; j++) {
-						numberButtons[j].bg.tint = 0x3498db;
-						numberButtons[j].clicked = false;
-					}
-					currentIndex = 0;
-					statusText.setText('Yanlış! Tekrar başla. Beklenen: 1');
-					statusText.tint = 0xff0000;
-					// Flash red to indicate error
-					LK.effects.flashScreen(0xff0000, 500);
 				}
 			};
-			numberButtons.push(numBtn);
-			overlay.addChild(numBtn);
+			keypadButtons.push(keyBtn);
+			overlay.addChild(keyBtn);
 		}
+		// Clear button
+		var clearBtn = new Container();
+		var clearBg = clearBtn.attachAsset('brick', {
+			anchorX: 0.5,
+			anchorY: 0.5,
+			scaleX: 1.2,
+			scaleY: 1.0
+		});
+		clearBg.tint = 0xe74c3c; // Red for clear
+		var clearText = new Text2('C', {
+			size: 70,
+			fill: 0xFFFFFF
+		});
+		clearText.anchor.set(0.5, 0.5);
+		clearBtn.addChild(clearText);
+		clearBtn.x = -200;
+		clearBtn.y = 160;
+		clearBtn.down = function () {
+			enteredPassword = '';
+			passwordDisplay.setText('****');
+			passwordDisplay.tint = 0x00ff00;
+		};
+		overlay.addChild(clearBtn);
 		// Back button
 		var backBtn = new Container();
 		var backBg = backBtn.attachAsset('brick', {
 			anchorX: 0.5,
@@ -583,10 +613,10 @@
 			fill: 0xFFFFFF
 		});
 		backText.anchor.set(0.5, 0.5);
 		backBtn.addChild(backText);
-		backBtn.x = 0;
-		backBtn.y = 500;
+		backBtn.x = 200;
+		backBtn.y = 160;
 		backBtn.down = function () {
 			self.removeChild(overlay);
 			overlay.destroy();
 		};