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

/**** 
* Classes
****/ 
var Ball = Container.expand(function (theme) {
	var self = Container.call(this);
	theme = theme || currentTheme;
	var ballAsset = themeAssets[theme].ball;
	var ballGraphics = self.attachAsset(ballAsset, {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.velocityX = 0;
	self.velocityY = 0;
	self.speed = 12; // Reduced speed for slower gameplay
	self.update = function () {
		if (self.destroyed) return;
		self.x += self.velocityX;
		self.y += self.velocityY;
		// Wall collision detection
		if (self.x <= 10 || self.x >= 2038) {
			self.velocityX = -self.velocityX;
			self.x = Math.max(10, Math.min(2038, self.x));
			LK.getSound('wallHit').play();
		}
		if (self.y <= 10) {
			self.velocityY = -self.velocityY;
			self.y = Math.max(10, self.y);
			LK.getSound('wallHit').play();
		}
	};
	self.destroyed = false;
	self.destroy = function () {
		if (!self.destroyed) {
			self.destroyed = true;
			if (self.parent) {
				self.parent.removeChild(self);
			}
		}
	};
	return self;
});
var Brick = Container.expand(function (brickType, theme) {
	var self = Container.call(this);
	theme = theme || currentTheme;
	var brickAsset;
	if (theme === 'classic') {
		brickAsset = 'brick' + (brickType || 1);
	} else {
		brickAsset = themeAssets[theme].brick;
	}
	var brickGraphics = self.attachAsset(brickAsset, {
		anchorX: 0.5,
		anchorY: 0.5
	});
	if (theme !== 'classic' && brickType) {
		var colors = [0xff0080, 0x00ff80, 0x8000ff, 0xffff00, 0xff8000];
		brickGraphics.tint = colors[(brickType - 1) % colors.length];
	}
	self.destroyed = false;
	self.destroy = function () {
		if (!self.destroyed) {
			self.destroyed = true;
			LK.effects.flashObject(self, 0xffffff, 200);
			tween(self, {
				alpha: 0,
				scaleX: 1.5,
				scaleY: 1.5
			}, {
				duration: 200,
				onFinish: function onFinish() {
					if (self.parent) {
						self.parent.removeChild(self);
					}
				}
			});
			LK.getSound('brickHit').play();
			LK.setScore(LK.getScore() + 10);
			// 20% chance to drop a powerup
			if (Math.random() < 0.2) {
				var powerupTypes = ['speed', 'expand', 'multiball'];
				var randomType = powerupTypes[Math.floor(Math.random() * powerupTypes.length)];
				var powerup = new PowerUp(randomType);
				powerup.x = self.x;
				powerup.y = self.y;
				powerups.push(powerup);
				game.addChild(powerup);
			}
			return true;
		}
		return false;
	};
	return self;
});
var Laser = Container.expand(function () {
	var self = Container.call(this);
	var laserGraphics = self.attachAsset('paddle', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	laserGraphics.tint = 0xff0000;
	laserGraphics.width = 8;
	laserGraphics.height = 600;
	laserGraphics.alpha = 1.0;
	self.speed = 25;
	self.destroyed = false;
	self.update = function () {
		if (self.destroyed) return;
		self.y -= self.speed;
		// Remove if off screen
		if (self.y < -200) {
			self.destroy();
		}
	};
	self.destroy = function () {
		if (!self.destroyed) {
			self.destroyed = true;
			if (self.parent) {
				self.parent.removeChild(self);
			}
		}
	};
	return self;
});
var MenuButton = Container.expand(function (text, action) {
	var self = Container.call(this);
	self.buttonGraphics = self.attachAsset('menuButton', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.buttonText = new Text2(text, {
		size: 39,
		fill: 0xffffff
	});
	self.buttonText.anchor.set(0.5, 0.5);
	self.addChild(self.buttonText);
	self.action = action;
	self.isHovered = false;
	self.down = function (x, y, obj) {
		LK.getSound('menuSelect').play();
		if (self.action) {
			self.action();
		}
	};
	self.move = function (x, y, obj) {
		if (!self.isHovered) {
			self.isHovered = true;
			var currentScaleX = self.buttonGraphics.scaleX || 1;
			var currentScaleY = self.buttonGraphics.scaleY || 1;
			self.removeChild(self.buttonGraphics);
			self.buttonGraphics = self.attachAsset('menuButtonHover', {
				anchorX: 0.5,
				anchorY: 0.5
			});
			self.buttonGraphics.scaleX = currentScaleX;
			self.buttonGraphics.scaleY = currentScaleY;
			self.addChildAt(self.buttonGraphics, 0);
			tween(self, {
				scaleX: 1.1,
				scaleY: 1.1
			}, {
				duration: 200
			});
		}
	};
	return self;
});
var Paddle = Container.expand(function (theme) {
	var self = Container.call(this);
	theme = theme || currentTheme;
	var paddleAsset = themeAssets[theme].paddle;
	var paddleGraphics = self.attachAsset(paddleAsset, {
		anchorX: 0.5,
		anchorY: 0.5
	});
	return self;
});
var PowerUp = Container.expand(function (type) {
	var self = Container.call(this);
	self.type = type || 'speed';
	var colors = {
		speed: 0xff4444,
		expand: 0x44ff44,
		multiball: 0x4444ff
	};
	var powerupGraphics = self.attachAsset('ball', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	powerupGraphics.tint = colors[self.type];
	powerupGraphics.width = 30;
	powerupGraphics.height = 30;
	self.velocityY = 3;
	self.collected = false;
	self.update = function () {
		self.y += self.velocityY;
		// Remove if off screen
		if (self.y > 2800) {
			if (self.parent) {
				self.parent.removeChild(self);
			}
		}
		// Check collection by paddle
		if (!self.collected && self.intersects(paddle)) {
			self.collected = true;
			self.applyEffect();
			if (self.parent) {
				self.parent.removeChild(self);
			}
		}
	};
	self.applyEffect = function () {
		switch (self.type) {
			case 'speed':
				// Speed powerup now just creates visual effect without changing speed
				createEdgeGlow(0xff4444);
				break;
			case 'expand':
				tween(paddle, {
					scaleX: 1.5
				}, {
					duration: 500
				});
				LK.setTimeout(function () {
					tween(paddle, {
						scaleX: 1
					}, {
						duration: 500
					});
				}, 10000);
				createEdgeGlow(0x44ff44);
				break;
			case 'multiball':
				// Create two additional balls
				for (var i = 0; i < 2; i++) {
					var newBall = game.addChild(new Ball());
					newBall.x = ball.x + (i - 0.5) * 50;
					newBall.y = ball.y;
					newBall.velocityX = ball.velocityX + (i - 0.5) * 4;
					newBall.velocityY = ball.velocityY;
					newBall.speed = ball.speed;
					extraBalls.push(newBall);
				}
				createEdgeGlow(0x4444ff);
				break;
		}
	};
	return self;
});

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

/**** 
* Game Code
****/ 
var paddle;
var ball;
var bricks = [];
var powerups = [];
var extraBalls = [];
var gameStarted = false;
var dragNode = null;
var gameState = 'menu'; // 'menu', 'playing', 'levelSelect'
var currentLevel = 1;
var gameMode = 'classic'; // 'classic', 'endless', 'timeAttack', 'zen', 'gravity', 'reverse', 'laser'
var currentTheme = 'classic'; // 'classic', 'dark', 'neon', 'gold', 'ice', 'fire'
var zenModeActive = false;
var gravityModeActive = false;
var reverseModeActive = false;
var laserModeActive = false;
var laserBeams = [];
var laserCooldown = 0;
var gravityDirection = 1; // 1 for down, -1 for up
var themeAssets = {
	classic: {
		brick: 'brick',
		paddle: 'paddle',
		ball: 'ball'
	},
	dark: {
		brick: 'darkBrick',
		paddle: 'darkPaddle',
		ball: 'darkBall'
	},
	neon: {
		brick: 'neonBrick',
		paddle: 'neonPaddle',
		ball: 'neonBall'
	},
	gold: {
		brick: 'goldBrick',
		paddle: 'goldPaddle',
		ball: 'goldBall'
	},
	ice: {
		brick: 'iceBrick',
		paddle: 'icePaddle',
		ball: 'iceBall'
	},
	fire: {
		brick: 'fireBrick',
		paddle: 'firePaddle',
		ball: 'fireBall'
	},
	space: {
		brick: 'darkBrick',
		paddle: 'darkPaddle',
		ball: 'neonBall'
	},
	galaxy: {
		brick: 'neonBrick',
		paddle: 'goldPaddle',
		ball: 'fireBall'
	}
};
var themeBackgrounds = {
	classic: 0x0a0a0a,
	dark: 0x2c2c54,
	neon: 0x0f3460,
	gold: 0x2c1810,
	ice: 0x1e3a5f,
	fire: 0x2a0a0a,
	space: 'spaceBackground',
	galaxy: 'galaxyBackground'
};
var menuContainer;
var levelSelectContainer;
var highScore = storage.highScore || 0;
// Create edge glow effect
function createEdgeGlow(color) {
	// Create glow shapes for each edge
	var glowShapes = [];
	// Top edge
	var topGlow = LK.getAsset('paddle', {
		anchorX: 0,
		anchorY: 0,
		scaleX: 20.5,
		scaleY: 0.3
	});
	topGlow.tint = color;
	topGlow.x = 0;
	topGlow.y = 0;
	topGlow.alpha = 0.8;
	game.addChild(topGlow);
	glowShapes.push(topGlow);
	// Bottom edge
	var bottomGlow = LK.getAsset('paddle', {
		anchorX: 0,
		anchorY: 0,
		scaleX: 20.5,
		scaleY: 0.3
	});
	bottomGlow.tint = color;
	bottomGlow.x = 0;
	bottomGlow.y = 2720;
	bottomGlow.alpha = 0.8;
	game.addChild(bottomGlow);
	glowShapes.push(bottomGlow);
	// Left edge
	var leftGlow = LK.getAsset('paddle', {
		anchorX: 0,
		anchorY: 0,
		scaleX: 0.5,
		scaleY: 27.3
	});
	leftGlow.tint = color;
	leftGlow.x = 0;
	leftGlow.y = 0;
	leftGlow.alpha = 0.8;
	game.addChild(leftGlow);
	glowShapes.push(leftGlow);
	// Right edge
	var rightGlow = LK.getAsset('paddle', {
		anchorX: 0,
		anchorY: 0,
		scaleX: 0.5,
		scaleY: 27.3
	});
	rightGlow.tint = color;
	rightGlow.x = 2038;
	rightGlow.y = 0;
	rightGlow.alpha = 0.8;
	game.addChild(rightGlow);
	glowShapes.push(rightGlow);
	// Animate all glow shapes
	for (var i = 0; i < glowShapes.length; i++) {
		tween(glowShapes[i], {
			alpha: 0
		}, {
			duration: 300,
			onFinish: function () {
				if (this.parent) {
					this.parent.removeChild(this);
				}
			}.bind(glowShapes[i])
		});
	}
}
// Create score display
var scoreTxt = new Text2('0', {
	size: 60,
	fill: 0x00FFFF
});
scoreTxt.setText(LK.getScore());
scoreTxt.anchor.set(0.5, 0);
LK.gui.top.addChild(scoreTxt);
// Create main menu
function createMainMenu() {
	menuContainer = game.addChild(new Container());
	// Menu background
	var menuBg = menuContainer.attachAsset('menuBackground', {
		anchorX: 0.5,
		anchorY: 0.5,
		scaleX: 1.4,
		scaleY: 1.4
	});
	menuBg.alpha = 0.9;
	menuContainer.x = 1024;
	menuContainer.y = 1366;
	// Game title
	var titleText = new Text2('BRICK BREAKER', {
		size: 67,
		fill: 0x00ffff
	});
	titleText.anchor.set(0.5, 0.5);
	titleText.y = -250;
	menuContainer.addChild(titleText);
	// High score display
	var highScoreText = new Text2('High Score: ' + highScore, {
		size: 34,
		fill: 0xffff00
	});
	highScoreText.anchor.set(0.5, 0.5);
	highScoreText.y = -180;
	menuContainer.addChild(highScoreText);
	// Menu buttons
	var classicButton = menuContainer.addChild(new MenuButton('Classic Mode', function () {
		gameMode = 'classic';
		startClassicGame();
	}));
	classicButton.y = -60;
	classicButton.buttonGraphics.scaleX = 1.2;
	classicButton.buttonGraphics.scaleY = 1.2;
	classicButton.buttonText.size = 36;
	var endlessButton = menuContainer.addChild(new MenuButton('Endless Mode', function () {
		gameMode = 'endless';
		startEndlessGame();
	}));
	endlessButton.y = 10;
	endlessButton.buttonGraphics.scaleX = 1.2;
	endlessButton.buttonGraphics.scaleY = 1.2;
	endlessButton.buttonText.size = 36;
	var timeAttackButton = menuContainer.addChild(new MenuButton('Time Attack', function () {
		gameMode = 'timeAttack';
		startTimeAttackGame();
	}));
	timeAttackButton.y = 80;
	timeAttackButton.buttonGraphics.scaleX = 1.2;
	timeAttackButton.buttonGraphics.scaleY = 1.2;
	timeAttackButton.buttonText.size = 36;
	var zenButton = menuContainer.addChild(new MenuButton('Zen Mode', function () {
		gameMode = 'zen';
		startZenGame();
	}));
	zenButton.y = 150;
	zenButton.buttonGraphics.scaleX = 1.2;
	zenButton.buttonGraphics.scaleY = 1.2;
	zenButton.buttonText.size = 36;
	var gravityButton = menuContainer.addChild(new MenuButton('Gravity Mode', function () {
		gameMode = 'gravity';
		startGravityGame();
	}));
	gravityButton.y = 220;
	gravityButton.buttonGraphics.scaleX = 1.2;
	gravityButton.buttonGraphics.scaleY = 1.2;
	gravityButton.buttonText.size = 36;
	var reverseButton = menuContainer.addChild(new MenuButton('Reverse Mode', function () {
		gameMode = 'reverse';
		startReverseGame();
	}));
	reverseButton.y = 290;
	reverseButton.buttonGraphics.scaleX = 1.2;
	reverseButton.buttonGraphics.scaleY = 1.2;
	reverseButton.buttonText.size = 36;
	var laserButton = menuContainer.addChild(new MenuButton('Laser Mode', function () {
		gameMode = 'laser';
		startLaserGame();
	}));
	laserButton.y = 360;
	laserButton.buttonGraphics.scaleX = 1.2;
	laserButton.buttonGraphics.scaleY = 1.2;
	laserButton.buttonText.size = 36;
	var themeButton = menuContainer.addChild(new MenuButton('Themes', function () {
		showThemeSelect();
	}));
	themeButton.y = 430;
	themeButton.buttonGraphics.scaleX = 1.2;
	themeButton.buttonGraphics.scaleY = 1.2;
	themeButton.buttonText.size = 36;
	var levelSelectButton = menuContainer.addChild(new MenuButton('Level Select', function () {
		showLevelSelect();
	}));
	levelSelectButton.y = 500;
	levelSelectButton.buttonGraphics.scaleX = 1.2;
	levelSelectButton.buttonGraphics.scaleY = 1.2;
	levelSelectButton.buttonText.size = 36;
	// Animate menu entrance
	menuContainer.alpha = 0;
	menuContainer.scaleX = 0.5;
	menuContainer.scaleY = 0.5;
	tween(menuContainer, {
		alpha: 1,
		scaleX: 1,
		scaleY: 1
	}, {
		duration: 500
	});
}
function hideMenu() {
	if (menuContainer) {
		tween(menuContainer, {
			alpha: 0,
			scaleY: 0
		}, {
			duration: 300,
			onFinish: function onFinish() {
				if (menuContainer.parent) {
					menuContainer.parent.removeChild(menuContainer);
				}
				menuContainer = null;
			}
		});
	}
}
function showLevelSelect() {
	hideMenu();
	levelSelectContainer = game.addChild(new Container());
	// Level select background
	var levelBg = levelSelectContainer.attachAsset('menuBackground', {
		anchorX: 0.5,
		anchorY: 0.5,
		scaleX: 2.0,
		scaleY: 2.2
	});
	levelBg.alpha = 0.9;
	levelSelectContainer.x = 1024;
	levelSelectContainer.y = 1366;
	// Title
	var levelTitle = new Text2('SELECT LEVEL', {
		size: 50,
		fill: 0x00ffff
	});
	levelTitle.anchor.set(0.5, 0.5);
	levelTitle.y = -350;
	levelSelectContainer.addChild(levelTitle);
	// Level buttons (5x3 grid for 15 levels)
	for (var i = 1; i <= 15; i++) {
		var levelButton = levelSelectContainer.addChild(new MenuButton('Level ' + i, function (level) {
			return function () {
				currentLevel = level;
				gameMode = 'level';
				startLevelGame(level);
			};
		}(i)));
		var row = Math.floor((i - 1) / 5);
		var col = (i - 1) % 5;
		levelButton.x = (col - 2) * 200;
		levelButton.y = -180 + row * 140;
		levelButton.buttonGraphics.scaleX = 0.44;
		levelButton.buttonGraphics.scaleY = 0.6;
		levelButton.buttonText.size = 28;
	}
	// Back button
	var backButton = levelSelectContainer.addChild(new MenuButton('Back', function () {
		hideLevelSelect();
		createMainMenu();
	}));
	backButton.y = 350;
	// Animate entrance
	levelSelectContainer.alpha = 0;
	tween(levelSelectContainer, {
		alpha: 1
	}, {
		duration: 300
	});
}
function hideLevelSelect() {
	if (levelSelectContainer) {
		tween(levelSelectContainer, {
			alpha: 0
		}, {
			duration: 200,
			onFinish: function onFinish() {
				if (levelSelectContainer.parent) {
					levelSelectContainer.parent.removeChild(levelSelectContainer);
				}
				levelSelectContainer = null;
			}
		});
	}
}
var themeSelectContainer;
var themeSelectOpen = false;
function hideThemeSelect() {
	if (themeSelectContainer) {
		themeSelectOpen = false;
		tween(themeSelectContainer, {
			alpha: 0
		}, {
			duration: 200,
			onFinish: function onFinish() {
				if (themeSelectContainer.parent) {
					themeSelectContainer.parent.removeChild(themeSelectContainer);
				}
				themeSelectContainer = null;
			}
		});
	}
}
function showThemeSelect() {
	if (themeSelectOpen) {
		// If theme menu is open, close it
		hideThemeSelect();
		createMainMenu();
		return;
	}
	if (!menuContainer) {
		// If menu is not showing, don't open theme menu
		return;
	}
	hideMenu();
	themeSelectOpen = true;
	themeSelectContainer = game.addChild(new Container());
	// Theme select background
	var themeBg = themeSelectContainer.attachAsset('menuBackground', {
		anchorX: 0.5,
		anchorY: 0.5,
		scaleX: 2.0,
		scaleY: 2.2
	});
	themeBg.alpha = 0.9;
	themeSelectContainer.x = 1024;
	themeSelectContainer.y = 1366;
	// Title
	var themeTitle = new Text2('SELECT THEME', {
		size: 50,
		fill: 0x00ffff
	});
	themeTitle.anchor.set(0.5, 0.5);
	themeTitle.y = -350;
	themeSelectContainer.addChild(themeTitle);
	// Theme buttons
	var themes = ['classic', 'dark', 'neon', 'gold', 'ice', 'fire', 'space', 'galaxy'];
	var themeNames = ['Classic', 'Dark', 'Neon', 'Gold', 'Ice', 'Fire', 'Space', 'Galaxy'];
	for (var i = 0; i < themes.length; i++) {
		var themeButton = themeSelectContainer.addChild(new MenuButton(themeNames[i], function (theme) {
			return function () {
				currentTheme = theme;
				if (typeof themeBackgrounds[theme] === 'string') {
					// If it's an image asset name, add background image
					if (game.backgroundImage) {
						game.removeChild(game.backgroundImage);
					}
					game.backgroundImage = game.attachAsset(themeBackgrounds[theme], {
						anchorX: 0,
						anchorY: 0,
						scaleX: 1,
						scaleY: 1
					});
					game.addChildAt(game.backgroundImage, 0);
				} else {
					// If it's a color, set background color
					if (game.backgroundImage) {
						game.removeChild(game.backgroundImage);
						game.backgroundImage = null;
					}
					game.setBackgroundColor(themeBackgrounds[theme]);
				}
				hideThemeSelect();
				createMainMenu();
			};
		}(themes[i])));
		var row = Math.floor(i / 4);
		var col = i % 4;
		themeButton.x = (col - 1.5) * 220;
		themeButton.y = -200 + row * 120;
		themeButton.buttonGraphics.scaleX = 0.5;
		themeButton.buttonGraphics.scaleY = 0.5;
	}
	// Back button
	var backButton = themeSelectContainer.addChild(new MenuButton('Back', function () {
		hideThemeSelect();
		createMainMenu();
	}));
	backButton.y = 350;
	// Animate entrance
	themeSelectContainer.alpha = 0;
	tween(themeSelectContainer, {
		alpha: 1
	}, {
		duration: 300
	});
}
function startClassicGame() {
	hideMenu();
	gameState = 'playing';
	initializeGame();
}
function startEndlessGame() {
	hideMenu();
	gameState = 'playing';
	initializeGame();
	// In endless mode, we'll regenerate bricks when they're all destroyed
}
function startTimeAttackGame() {
	hideMenu();
	gameState = 'playing';
	initializeGame();
	// Add timer for time attack mode
	var timeLeft = 120; // 2 minutes
	var timeText = new Text2('Time: ' + timeLeft, {
		size: 30,
		fill: 0xff0000
	});
	timeText.anchor.set(1, 0);
	LK.gui.topRight.addChild(timeText);
	var timeTimer = LK.setInterval(function () {
		timeLeft--;
		timeText.setText('Time: ' + timeLeft);
		if (timeLeft <= 0) {
			LK.clearInterval(timeTimer);
			LK.showGameOver();
		}
	}, 1000);
}
function startLevelGame(level) {
	hideLevelSelect();
	gameState = 'playing';
	initializeGame();
	createLevelBricks(level);
}
function startZenGame() {
	hideMenu();
	gameState = 'playing';
	zenModeActive = true;
	initializeGame();
	// Create peaceful, slowly moving bricks
	createZenBricks();
	// Add zen mode indicator
	var zenText = new Text2('ZEN MODE - Relax and enjoy', {
		size: 25,
		fill: 0x90EE90
	});
	zenText.anchor.set(0.5, 0);
	zenText.y = 100;
	LK.gui.top.addChild(zenText);
}
function startGravityGame() {
	hideMenu();
	gameState = 'playing';
	gravityModeActive = true;
	initializeGame();
	// Create bricks for gravity mode
	createBricks();
	// Start ball with initial velocity for gravity mode
	ball.velocityX = (Math.random() - 0.5) * 8;
	ball.velocityY = -ball.speed * 0.8;
	gameStarted = true;
	// Add gravity mode indicator
	var gravityText = new Text2('GRAVITY MODE - Gravity changes every 10 seconds!', {
		size: 25,
		fill: 0xff6b6b
	});
	gravityText.anchor.set(0.5, 0);
	gravityText.y = 100;
	LK.gui.top.addChild(gravityText);
	// Set up gravity timer
	LK.setInterval(function () {
		gravityDirection *= -1;
		createEdgeGlow(gravityDirection > 0 ? 0xff0000 : 0x0000ff);
	}, 10000);
}
function startReverseGame() {
	hideMenu();
	gameState = 'playing';
	reverseModeActive = true;
	initializeGame();
	// Create bricks for reverse mode (positioned lower for reverse gameplay)
	var brickColors = [1, 2, 3, 4, 5];
	var rows = 8;
	var cols = 18;
	var brickWidth = 110;
	var brickHeight = 50;
	var startX = 110;
	var startY = 1800; // Lower position for reverse mode
	for (var row = 0; row < rows; row++) {
		for (var col = 0; col < cols; col++) {
			var brick = new Brick(brickColors[row % brickColors.length], currentTheme);
			brick.x = startX + col * brickWidth;
			brick.y = startY + row * brickHeight;
			bricks.push(brick);
			game.addChild(brick);
		}
	}
	// Place paddle at top instead of bottom
	paddle.y = 150;
	ball.x = 1024;
	ball.y = 200;
	ball.velocityX = (Math.random() - 0.5) * 8;
	ball.velocityY = ball.speed;
	gameStarted = true;
	// Add reverse mode indicator
	var reverseText = new Text2('REVERSE MODE - Paddle is at the top!', {
		size: 25,
		fill: 0x9b59b6
	});
	reverseText.anchor.set(0.5, 0);
	reverseText.y = 100;
	LK.gui.top.addChild(reverseText);
}
function startLaserGame() {
	hideMenu();
	gameState = 'playing';
	laserModeActive = true;
	initializeGame();
	// Create bricks for laser mode
	createBricks();
	// Start ball with initial velocity for laser mode
	ball.velocityX = (Math.random() - 0.5) * 8;
	ball.velocityY = -ball.speed * 0.8;
	gameStarted = true;
	// Initialize laser variables
	laserCooldown = 0;
	laserBeams = [];
	// Add laser mode indicator
	var laserText = new Text2('LASER MODE - Tap to shoot laser beams!', {
		size: 25,
		fill: 0xff6b6b
	});
	laserText.anchor.set(0.5, 0);
	laserText.y = 100;
	LK.gui.top.addChild(laserText);
}
function clearLevelElements() {
	// Remove all existing bricks from screen
	for (var i = 0; i < bricks.length; i++) {
		if (bricks[i].parent) {
			bricks[i].parent.removeChild(bricks[i]);
		}
	}
	// Remove all existing powerups from screen
	for (var p = 0; p < powerups.length; p++) {
		if (powerups[p].parent) {
			powerups[p].parent.removeChild(powerups[p]);
		}
	}
	// Remove all extra balls from screen
	for (var e = 0; e < extraBalls.length; e++) {
		if (extraBalls[e].parent) {
			extraBalls[e].parent.removeChild(extraBalls[e]);
		}
	}
	// Remove all laser beams from screen
	for (var lb = 0; lb < laserBeams.length; lb++) {
		if (laserBeams[lb].parent) {
			laserBeams[lb].parent.removeChild(laserBeams[lb]);
		}
	}
	// Clear GUI elements that might be from previous level
	var guiChildren = LK.gui.topRight.children.slice();
	for (var g = 0; g < guiChildren.length; g++) {
		if (guiChildren[g] !== scoreTxt) {
			LK.gui.topRight.removeChild(guiChildren[g]);
		}
	}
	var guiTopChildren = LK.gui.top.children.slice();
	for (var gt = 0; gt < guiTopChildren.length; gt++) {
		if (guiTopChildren[gt] !== scoreTxt) {
			LK.gui.top.removeChild(guiTopChildren[gt]);
		}
	}
}
function initializeGame() {
	// Clear previous level elements first
	clearLevelElements();
	// Reset game variables
	bricks = [];
	powerups = [];
	extraBalls = [];
	laserBeams = [];
	gameStarted = false;
	zenModeActive = false;
	gravityModeActive = false;
	reverseModeActive = false;
	laserModeActive = false;
	laserCooldown = 0;
	gravityDirection = 1;
	LK.setScore(0);
	// Create game objects if they don't exist
	if (!paddle) {
		paddle = game.addChild(new Paddle(currentTheme));
	} else {
		// Update paddle for new theme
		paddle.parent.removeChild(paddle);
		paddle = game.addChild(new Paddle(currentTheme));
	}
	if (!ball) {
		ball = game.addChild(new Ball(currentTheme));
	} else {
		// Update ball for new theme  
		ball.parent.removeChild(ball);
		ball = game.addChild(new Ball(currentTheme));
	}
	// Reset positions
	paddle.x = 1024;
	paddle.y = 2600;
	ball.x = 1024;
	ball.y = 2550;
	ball.velocityX = 0;
	ball.velocityY = 0;
	if (gameMode === 'classic' || gameMode === 'endless' || gameMode === 'timeAttack') {
		createBricks();
	}
	// Start ball movement immediately for level-based games
	if (gameMode === 'level') {
		ball.velocityX = (Math.random() - 0.5) * 10;
		ball.velocityY = -ball.speed;
		gameStarted = true;
	}
	// Create back to menu button
	var backToMenuButton = new MenuButton('Menu', function () {
		gameState = 'menu';
		createMainMenu();
	});
	backToMenuButton.buttonGraphics.scaleX = 0.4;
	backToMenuButton.buttonGraphics.scaleY = 0.4;
	backToMenuButton.buttonText.size = 25;
	backToMenuButton.x = 1800;
	backToMenuButton.y = 150;
	game.addChild(backToMenuButton);
}
function createLevelBricks(level) {
	// Clear any existing bricks before creating new pattern
	clearLevelElements();
	var patterns = {
		1: function _() {
			createSimplePattern();
		},
		2: function _() {
			createDiamondPattern();
		},
		3: function _() {
			createCheckerPattern();
		},
		4: function _() {
			createWavePattern();
		},
		5: function _() {
			createCirclePattern();
		},
		6: function _() {
			createTrianglePattern();
		},
		7: function _() {
			createCrossPattern();
		},
		8: function _() {
			createSpiralPattern();
		},
		9: function _() {
			createRandomPattern();
		},
		10: function _() {
			createHexagonPattern();
		},
		11: function _() {
			createZigZagPattern();
		},
		12: function _() {
			createHeartPattern();
		},
		13: function _() {
			createMazePattern();
		},
		14: function _() {
			createStarPattern();
		},
		15: function _() {
			createDoubleCirclePattern();
		}
	};
	if (patterns[level]) {
		patterns[level]();
	} else {
		createBricks();
	}
}
function createSimplePattern() {
	var rows = 6;
	var cols = 14;
	var brickWidth = 140;
	var brickHeight = 45;
	var startX = 1024 - cols * brickWidth / 2 + brickWidth / 2;
	var startY = 250;
	for (var row = 0; row < rows; row++) {
		for (var col = 0; col < cols; col++) {
			var brickType = (row * cols + col) % 8 + 1;
			var brick = new Brick(brickType, currentTheme);
			brick.x = startX + col * brickWidth;
			brick.y = startY + row * brickHeight;
			bricks.push(brick);
			game.addChild(brick);
		}
	}
}
function createDiamondPattern() {
	var centerX = 1024;
	var centerY = 350;
	var brickWidth = 100;
	var brickHeight = 40;
	var diamond = [[0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0], [0, 0, 0, 2, 2, 2, 2, 2, 0, 0, 0], [0, 0, 3, 3, 3, 3, 3, 3, 3, 0, 0], [0, 4, 4, 4, 4, 4, 4, 4, 4, 4, 0], [5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5], [6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6], [0, 7, 7, 7, 7, 7, 7, 7, 7, 7, 0], [0, 0, 8, 8, 8, 8, 8, 8, 8, 0, 0], [0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0], [0, 0, 0, 0, 2, 2, 2, 0, 0, 0, 0], [0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0]];
	for (var row = 0; row < diamond.length; row++) {
		for (var col = 0; col < diamond[row].length; col++) {
			if (diamond[row][col] > 0) {
				var brick = new Brick(diamond[row][col]);
				brick.x = centerX + (col - 5) * brickWidth;
				brick.y = centerY + row * brickHeight;
				bricks.push(brick);
				game.addChild(brick);
			}
		}
	}
}
function createCheckerPattern() {
	var rows = 12;
	var cols = 16;
	var brickWidth = 120;
	var brickHeight = 35;
	var startX = 1024 - cols * brickWidth / 2 + brickWidth / 2;
	var startY = 200;
	for (var row = 0; row < rows; row++) {
		for (var col = 0; col < cols; col++) {
			if ((row + col) % 2 === 0) {
				var brickType = (row + col) % 8 + 1;
				var brick = new Brick(brickType);
				brick.x = startX + col * brickWidth;
				brick.y = startY + row * brickHeight;
				bricks.push(brick);
				game.addChild(brick);
			} else if ((row + col) % 3 === 1) {
				// Add some bricks in alternate spaces for more density
				var brickType = row * col % 5 + 1;
				var brick = new Brick(brickType);
				brick.x = startX + col * brickWidth;
				brick.y = startY + row * brickHeight;
				bricks.push(brick);
				game.addChild(brick);
			}
		}
	}
}
function createWavePattern() {
	var cols = 15;
	var brickWidth = 130;
	var brickHeight = 45;
	var startX = 1024 - cols * brickWidth / 2 + brickWidth / 2;
	var baseY = 400;
	for (var col = 0; col < cols; col++) {
		var waveHeight = Math.sin(col * 0.5) * 100;
		var rows = Math.floor(3 + Math.abs(waveHeight / 50));
		for (var row = 0; row < rows; row++) {
			var brick = new Brick(col % 5 + 1);
			brick.x = startX + col * brickWidth;
			brick.y = baseY + waveHeight + row * brickHeight;
			bricks.push(brick);
			game.addChild(brick);
		}
	}
}
function createCirclePattern() {
	var centerX = 1024;
	var centerY = 450;
	var circles = [{
		radius: 80,
		bricks: 12,
		type: 1
	}, {
		radius: 140,
		bricks: 20,
		type: 2
	}, {
		radius: 200,
		bricks: 28,
		type: 3
	}, {
		radius: 260,
		bricks: 36,
		type: 4
	}, {
		radius: 320,
		bricks: 44,
		type: 5
	}];
	for (var c = 0; c < circles.length; c++) {
		var circle = circles[c];
		for (var i = 0; i < circle.bricks; i++) {
			var angle = i / circle.bricks * Math.PI * 2;
			var brickType = (circle.type + Math.floor(i / 4)) % 8 + 1;
			var brick = new Brick(brickType);
			brick.x = centerX + Math.cos(angle) * circle.radius;
			brick.y = centerY + Math.sin(angle) * circle.radius;
			bricks.push(brick);
			game.addChild(brick);
		}
	}
}
function createTrianglePattern() {
	var centerX = 1024;
	var startY = 300;
	var brickWidth = 120;
	var brickHeight = 50;
	for (var row = 0; row < 8; row++) {
		var bricksInRow = 8 - row;
		var startX = centerX - bricksInRow * brickWidth / 2 + brickWidth / 2;
		for (var col = 0; col < bricksInRow; col++) {
			var brick = new Brick(row % 5 + 1);
			brick.x = startX + col * brickWidth;
			brick.y = startY + row * brickHeight;
			bricks.push(brick);
			game.addChild(brick);
		}
	}
}
function createCrossPattern() {
	var centerX = 1024;
	var centerY = 450;
	var brickWidth = 100;
	var brickHeight = 40;
	// Horizontal line
	for (var i = -5; i <= 5; i++) {
		var brick = new Brick(3);
		brick.x = centerX + i * brickWidth;
		brick.y = centerY;
		bricks.push(brick);
		game.addChild(brick);
	}
	// Vertical line
	for (var i = -4; i <= 4; i++) {
		if (i !== 0) {
			// Don't place on center (already has horizontal brick)
			var brick = new Brick(5);
			brick.x = centerX;
			brick.y = centerY + i * brickHeight;
			bricks.push(brick);
			game.addChild(brick);
		}
	}
}
function createSpiralPattern() {
	var centerX = 1024;
	var centerY = 450;
	var brickWidth = 60;
	var brickHeight = 35;
	// Lion pattern - creating a stylized lion face
	var lionPattern = [
	// Mane (outer layer) - using brick type 6 (yellow/gold)
	[0, 0, 0, 0, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 0, 0, 0, 0], [0, 0, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 0, 0], [0, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 0], [6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6],
	// Face outline - using brick type 4 (yellow)
	[6, 6, 6, 6, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 6, 6, 6, 6], [6, 6, 6, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 6, 6, 6], [6, 6, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 6, 6],
	// Eyes area - using brick type 2 (green) for eyes, type 4 for face
	[6, 6, 4, 4, 4, 2, 2, 4, 4, 4, 4, 4, 2, 2, 4, 4, 4, 6, 6], [6, 6, 4, 4, 4, 2, 2, 4, 4, 4, 4, 4, 2, 2, 4, 4, 4, 6, 6],
	// Nose area - using brick type 1 (pink/red) for nose
	[6, 6, 4, 4, 4, 4, 4, 4, 1, 1, 1, 4, 4, 4, 4, 4, 4, 6, 6], [6, 6, 4, 4, 4, 4, 4, 4, 1, 1, 1, 4, 4, 4, 4, 4, 4, 6, 6],
	// Mouth area - using brick type 3 (purple) for mouth
	[6, 6, 4, 4, 4, 4, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 6, 6], [6, 6, 4, 4, 4, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 6, 6],
	// Lower face and chin
	[6, 6, 6, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 6, 6, 6], [6, 6, 6, 6, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 6, 6, 6, 6],
	// Bottom mane
	[0, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 0], [0, 0, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 0, 0], [0, 0, 0, 0, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 0, 0, 0, 0]];
	// Create bricks based on the lion pattern
	for (var row = 0; row < lionPattern.length; row++) {
		for (var col = 0; col < lionPattern[row].length; col++) {
			if (lionPattern[row][col] > 0) {
				var brickType = lionPattern[row][col];
				var brick = new Brick(brickType);
				brick.x = centerX + (col - 9) * brickWidth;
				brick.y = centerY + (row - 8) * brickHeight - 100;
				bricks.push(brick);
				game.addChild(brick);
			}
		}
	}
}
function createRandomPattern() {
	var brickCount = 80;
	var minX = 150;
	var maxX = 1898;
	var minY = 200;
	var maxY = 900;
	// Create clusters of bricks for more interesting gameplay
	var clusterCount = 8;
	var bricksPerCluster = brickCount / clusterCount;
	for (var cluster = 0; cluster < clusterCount; cluster++) {
		var clusterCenterX = minX + Math.random() * (maxX - minX);
		var clusterCenterY = minY + Math.random() * (maxY - minY);
		var clusterRadius = 80 + Math.random() * 40;
		for (var i = 0; i < bricksPerCluster; i++) {
			var angle = Math.random() * Math.PI * 2;
			var distance = Math.random() * clusterRadius;
			var brickType = Math.floor(Math.random() * 8) + 1;
			var brick = new Brick(brickType);
			brick.x = clusterCenterX + Math.cos(angle) * distance;
			brick.y = clusterCenterY + Math.sin(angle) * distance;
			// Ensure bricks stay within bounds
			brick.x = Math.max(minX, Math.min(maxX, brick.x));
			brick.y = Math.max(minY, Math.min(maxY, brick.y));
			bricks.push(brick);
			game.addChild(brick);
		}
	}
}
function createHexagonPattern() {
	var centerX = 1024;
	var centerY = 450;
	var radius = 180;
	var brickWidth = 100;
	var brickHeight = 40;
	// Create hexagon with 6 sides
	for (var side = 0; side < 6; side++) {
		var angle = side * Math.PI / 3;
		var sideLength = 8;
		for (var i = 0; i < sideLength; i++) {
			var brick = new Brick(side % 5 + 1);
			var x = centerX + Math.cos(angle) * radius + Math.cos(angle + Math.PI / 2) * (i - sideLength / 2) * brickWidth / 2;
			var y = centerY + Math.sin(angle) * radius + Math.sin(angle + Math.PI / 2) * (i - sideLength / 2) * brickHeight / 2;
			brick.x = x;
			brick.y = y;
			bricks.push(brick);
			game.addChild(brick);
		}
	}
}
function createZigZagPattern() {
	var cols = 16;
	var brickWidth = 120;
	var brickHeight = 45;
	var startX = 1024 - cols * brickWidth / 2 + brickWidth / 2;
	var baseY = 300;
	for (var col = 0; col < cols; col++) {
		var zigzagOffset = col % 4 * 60 - 90;
		var rows = 3 + Math.abs(zigzagOffset) / 30;
		for (var row = 0; row < rows; row++) {
			var brick = new Brick(col % 5 + 1);
			brick.x = startX + col * brickWidth;
			brick.y = baseY + zigzagOffset + row * brickHeight;
			bricks.push(brick);
			game.addChild(brick);
		}
	}
}
function createHeartPattern() {
	var centerX = 1024;
	var centerY = 400;
	var scale = 8;
	// Heart shape using parametric equations
	for (var t = 0; t < Math.PI * 2; t += 0.3) {
		var x = scale * (16 * Math.pow(Math.sin(t), 3));
		var y = scale * (13 * Math.cos(t) - 5 * Math.cos(2 * t) - 2 * Math.cos(3 * t) - Math.cos(4 * t));
		var brick = new Brick(Math.floor(t * 5 / (Math.PI * 2)) + 1);
		brick.x = centerX + x;
		brick.y = centerY - y + 100; // Flip and offset
		bricks.push(brick);
		game.addChild(brick);
	}
}
function createMazePattern() {
	var centerX = 1024;
	var centerY = 400;
	var brickWidth = 70;
	var brickHeight = 35;
	// Create larger, more complex maze-like pattern
	var mazePattern = [[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [1, 0, 0, 0, 2, 0, 0, 0, 3, 0, 3, 0, 0, 0, 4, 0, 0, 0, 1], [1, 0, 5, 5, 5, 5, 5, 0, 6, 0, 6, 0, 7, 7, 7, 7, 7, 0, 1], [1, 0, 5, 0, 0, 0, 5, 0, 0, 0, 0, 0, 7, 0, 0, 0, 7, 0, 1], [1, 0, 5, 0, 8, 0, 5, 8, 8, 8, 8, 8, 7, 0, 1, 0, 7, 0, 1], [1, 0, 5, 0, 8, 0, 0, 0, 0, 2, 0, 0, 0, 0, 1, 0, 7, 0, 1], [1, 0, 5, 5, 8, 5, 5, 5, 5, 2, 5, 5, 5, 5, 1, 5, 7, 0, 1], [1, 0, 0, 0, 8, 0, 0, 0, 0, 2, 0, 0, 0, 0, 1, 0, 0, 0, 1], [1, 3, 3, 3, 8, 3, 3, 0, 4, 2, 4, 0, 6, 6, 1, 6, 6, 3, 1], [1, 0, 0, 0, 8, 0, 0, 0, 4, 2, 4, 0, 0, 0, 1, 0, 0, 0, 1], [1, 0, 7, 7, 8, 7, 7, 7, 4, 2, 4, 7, 7, 7, 1, 7, 7, 0, 1], [1, 0, 0, 0, 0, 0, 0, 0, 4, 2, 4, 0, 0, 0, 0, 0, 0, 0, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]];
	for (var row = 0; row < mazePattern.length; row++) {
		for (var col = 0; col < mazePattern[row].length; col++) {
			if (mazePattern[row][col] > 0) {
				var brickType = mazePattern[row][col];
				var brick = new Brick(brickType);
				brick.x = centerX + (col - 9) * brickWidth;
				brick.y = centerY + (row - 6) * brickHeight;
				bricks.push(brick);
				game.addChild(brick);
			}
		}
	}
}
function createStarPattern() {
	var centerX = 1024;
	var centerY = 450;
	var outerRadius = 200;
	var innerRadius = 100;
	var points = 5;
	// Create 5-pointed star
	for (var i = 0; i < points * 2; i++) {
		var angle = i * Math.PI / points;
		var radius = i % 2 === 0 ? outerRadius : innerRadius;
		var bricksOnRay = 8;
		for (var j = 1; j <= bricksOnRay; j++) {
			var brick = new Brick(i % 5 + 1);
			brick.x = centerX + Math.cos(angle) * radius * j / bricksOnRay;
			brick.y = centerY + Math.sin(angle) * radius * j / bricksOnRay;
			bricks.push(brick);
			game.addChild(brick);
		}
	}
}
function createDoubleCirclePattern() {
	var centerX = 1024;
	var centerY = 450;
	var innerRadius = 120;
	var outerRadius = 220;
	var brickCount = 20;
	// Inner circle
	for (var i = 0; i < brickCount; i++) {
		var angle = i / brickCount * Math.PI * 2;
		var brick = new Brick(1, currentTheme);
		brick.x = centerX + Math.cos(angle) * innerRadius;
		brick.y = centerY + Math.sin(angle) * innerRadius;
		bricks.push(brick);
		game.addChild(brick);
	}
	// Outer circle
	for (var i = 0; i < brickCount * 1.5; i++) {
		var angle = i / (brickCount * 1.5) * Math.PI * 2;
		var brick = new Brick(3, currentTheme);
		brick.x = centerX + Math.cos(angle) * outerRadius;
		brick.y = centerY + Math.sin(angle) * outerRadius;
		bricks.push(brick);
		game.addChild(brick);
	}
	// Connecting lines
	for (var i = 0; i < 8; i++) {
		var angle = i / 8 * Math.PI * 2;
		for (var j = 1; j < 4; j++) {
			var radius = innerRadius + (outerRadius - innerRadius) * j / 4;
			var brick = new Brick(5, currentTheme);
			brick.x = centerX + Math.cos(angle) * radius;
			brick.y = centerY + Math.sin(angle) * radius;
			bricks.push(brick);
			game.addChild(brick);
		}
	}
}
function createZenBricks() {
	var centerX = 1024;
	var centerY = 400;
	var rows = 3;
	var cols = 8;
	var brickWidth = 140;
	var brickHeight = 60;
	var startX = centerX - cols * brickWidth / 2 + brickWidth / 2;
	var startY = centerY;
	for (var row = 0; row < rows; row++) {
		for (var col = 0; col < cols; col++) {
			var brick = new Brick(Math.floor(Math.random() * 5) + 1, currentTheme);
			brick.x = startX + col * brickWidth;
			brick.y = startY + row * brickHeight;
			brick.zenBrick = true;
			brick.floatOffset = Math.random() * Math.PI * 2;
			brick.originalY = brick.y;
			bricks.push(brick);
			game.addChild(brick);
		}
	}
}
// Show main menu on game start
createMainMenu();
// Create paddle
paddle = game.addChild(new Paddle());
paddle.x = 1024;
paddle.y = 2600;
// Create ball
ball = game.addChild(new Ball());
ball.x = 1024;
ball.y = 2550;
// Initialize ball movement when game starts
function startGame() {
	if (!gameStarted) {
		gameStarted = true;
		ball.velocityX = (Math.random() - 0.5) * 10;
		ball.velocityY = -ball.speed;
	}
}
// Create brick pattern
function createBricks() {
	var brickColors = [1, 2, 3, 4, 5, 6, 7, 8];
	var rows = 10;
	var cols = 20;
	var brickWidth = 100;
	var brickHeight = 42;
	var startX = 74;
	var startY = 180;
	for (var row = 0; row < rows; row++) {
		for (var col = 0; col < cols; col++) {
			// Create more interesting patterns with varying brick types
			var brickType;
			if (row < 2) {
				// Top rows use special stronger bricks
				brickType = col % 4 + 5;
			} else if (row === rows - 1) {
				// Bottom row alternates between types
				brickType = col % 2 === 0 ? 1 : 8;
			} else {
				// Middle rows use varied pattern
				brickType = row * col % 8 + 1;
			}
			var brick = new Brick(brickType, currentTheme);
			brick.x = startX + col * brickWidth;
			brick.y = startY + row * brickHeight;
			bricks.push(brick);
			game.addChild(brick);
		}
	}
}
createBricks();
// Event handlers
game.down = function (x, y, obj) {
	if (gameState === 'playing') {
		if (laserModeActive && laserCooldown <= 0) {
			// Shoot laser beam
			var laser = new Laser();
			laser.x = paddle.x;
			laser.y = paddle.y - 300; // Start laser higher up
			laserBeams.push(laser);
			game.addChild(laser);
			laserCooldown = 15; // Faster shooting - 1/4 second cooldown at 60fps
			LK.getSound('paddleHit').play();
		} else {
			dragNode = paddle;
		}
		// Only start game if it hasn't started yet and we're in a mode that requires manual start
		if (!gameStarted && (gameMode === 'classic' || gameMode === 'endless' || gameMode === 'timeAttack' || gameMode === 'zen')) {
			startGame();
		}
	}
};
game.move = function (x, y, obj) {
	if (gameState === 'playing' && dragNode) {
		dragNode.x = Math.max(100, Math.min(1948, x));
	}
};
game.up = function (x, y, obj) {
	if (gameState === 'playing') {
		dragNode = null;
	}
};
// Main game update loop
game.update = function () {
	// Only update game logic when actually playing
	if (gameState !== 'playing') {
		return;
	}
	// Update score display
	scoreTxt.setText(LK.getScore());
	// Update high score
	if (LK.getScore() > highScore) {
		highScore = LK.getScore();
		storage.highScore = highScore;
	}
	// Animate zen mode bricks
	if (zenModeActive) {
		for (var z = 0; z < bricks.length; z++) {
			if (bricks[z].zenBrick) {
				bricks[z].y = bricks[z].originalY + Math.sin(LK.ticks * 0.02 + bricks[z].floatOffset) * 10;
			}
		}
	}
	// Check if ball fell below paddle (or above in reverse mode)
	var ballOutOfBounds = reverseModeActive ? ball.y < -20 : ball.y > 2750;
	if (ballOutOfBounds) {
		if (gameMode === 'zen') {
			// In zen mode, just reset the ball
			ball.x = 1024;
			ball.y = reverseModeActive ? 200 : 2550;
			ball.velocityX = 0;
			ball.velocityY = 0;
			gameStarted = false;
			// Reset paddle position for zen mode
			paddle.y = reverseModeActive ? 150 : 2600;
			return;
		} else {
			LK.showGameOver();
			gameState = 'menu';
			LK.setTimeout(function () {
				createMainMenu();
			}, 2000);
			return;
		}
	}
	// Apply gravity mode effects
	if (gravityModeActive && gameStarted) {
		ball.velocityY += 0.15 * gravityDirection;
		// Limit velocity to prevent uncontrollable speed
		ball.velocityY = Math.max(-12, Math.min(12, ball.velocityY));
		for (var eb = 0; eb < extraBalls.length; eb++) {
			extraBalls[eb].velocityY += 0.15 * gravityDirection;
			extraBalls[eb].velocityY = Math.max(-12, Math.min(12, extraBalls[eb].velocityY));
		}
	}
	// Laser mode mechanics
	if (laserModeActive) {
		// Decrease laser cooldown
		if (laserCooldown > 0) {
			laserCooldown--;
		}
		// Update laser beams and check collisions
		for (var lb = laserBeams.length - 1; lb >= 0; lb--) {
			var laser = laserBeams[lb];
			// Update laser position (call update method)
			laser.update();
			if (laser.destroyed) {
				laserBeams.splice(lb, 1);
				continue;
			}
			// Check laser-brick collisions
			for (var i = bricks.length - 1; i >= 0; i--) {
				var brick = bricks[i];
				if (!brick.destroyed && laser.intersects(brick)) {
					brick.destroy();
					bricks.splice(i, 1);
					laser.destroy();
					laserBeams.splice(lb, 1);
					LK.effects.flashObject(laser, 0xffffff, 200);
					break;
				}
			}
		}
	}
	// Ball-paddle collision (updated for reverse mode)
	var paddleCollisionCheck = reverseModeActive ? ball.intersects(paddle) && ball.velocityY < 0 && ball.y > paddle.y - 15 : ball.intersects(paddle) && ball.velocityY > 0 && ball.y < paddle.y + 15;
	if (paddleCollisionCheck) {
		var paddleCenter = paddle.x;
		var ballRelativePosition = (ball.x - paddleCenter) / 100;
		if (reverseModeActive) {
			ball.velocityY = Math.abs(ball.velocityY);
			ball.y = paddle.y + 25;
		} else {
			ball.velocityY = -Math.abs(ball.velocityY);
			ball.y = paddle.y - 25;
		}
		ball.velocityX = ballRelativePosition * 8;
		LK.getSound('paddleHit').play();
	}
	// Ball-brick collisions
	for (var i = bricks.length - 1; i >= 0; i--) {
		var brick = bricks[i];
		if (!brick.destroyed && ball.intersects(brick)) {
			brick.destroy();
			bricks.splice(i, 1);
			// Simple bounce - reverse Y velocity
			ball.velocityY = -ball.velocityY;
			// In laser mode, create horizontal laser beam when ball hits brick
			if (laserModeActive) {
				var horizontalLaser = new Laser();
				horizontalLaser.x = brick.x;
				horizontalLaser.y = brick.y;
				// Make laser horizontal by swapping dimensions and changing speed direction
				var laserGraphics = horizontalLaser.children[0];
				laserGraphics.width = 600;
				laserGraphics.height = 8;
				laserGraphics.rotation = Math.PI / 2; // Rotate 90 degrees to make it horizontal
				horizontalLaser.speed = 0; // Don't move vertically
				horizontalLaser.horizontalSpeed = 15; // Move horizontally instead
				horizontalLaser.direction = ball.velocityX > 0 ? 1 : -1; // Move in ball's horizontal direction
				// Override update method for horizontal movement
				horizontalLaser.update = function () {
					if (this.destroyed) return;
					this.x += this.horizontalSpeed * this.direction;
					// Remove if off screen horizontally
					if (this.x < -200 || this.x > 2248) {
						this.destroy();
					}
				};
				laserBeams.push(horizontalLaser);
				game.addChild(horizontalLaser);
			}
			break;
		}
	}
	// Update powerups
	for (var p = powerups.length - 1; p >= 0; p--) {
		var powerup = powerups[p];
		if (powerup.y > 2800 || powerup.collected) {
			powerups.splice(p, 1);
		}
	}
	// Handle extra balls collisions
	for (var e = extraBalls.length - 1; e >= 0; e--) {
		var extraBall = extraBalls[e];
		// Remove if fallen below screen (or above in reverse mode)
		var extraBallOutOfBounds = reverseModeActive ? extraBall.y < -20 : extraBall.y > 2750;
		if (extraBallOutOfBounds) {
			extraBall.parent.removeChild(extraBall);
			extraBalls.splice(e, 1);
			continue;
		}
		// Extra ball-paddle collision (updated for reverse mode)
		var extraBallPaddleCheck = reverseModeActive ? extraBall.intersects(paddle) && extraBall.velocityY < 0 && extraBall.y > paddle.y - 15 : extraBall.intersects(paddle) && extraBall.velocityY > 0 && extraBall.y < paddle.y + 15;
		if (extraBallPaddleCheck) {
			var paddleCenter = paddle.x;
			var ballRelativePosition = (extraBall.x - paddleCenter) / 100;
			if (reverseModeActive) {
				extraBall.velocityY = Math.abs(extraBall.velocityY);
				extraBall.y = paddle.y + 25;
			} else {
				extraBall.velocityY = -Math.abs(extraBall.velocityY);
				extraBall.y = paddle.y - 25;
			}
			extraBall.velocityX = ballRelativePosition * 8;
		}
		// Extra ball-brick collisions
		for (var i = bricks.length - 1; i >= 0; i--) {
			var brick = bricks[i];
			if (!brick.destroyed && extraBall.intersects(brick)) {
				brick.destroy();
				bricks.splice(i, 1);
				extraBall.velocityY = -extraBall.velocityY;
				break;
			}
		}
	}
	// Check win condition
	if (bricks.length === 0) {
		if (gameMode === 'endless') {
			// In endless mode, create new bricks
			createBricks();
			LK.setScore(LK.getScore() + 500); // Bonus for completing a level
		} else {
			LK.showYouWin();
			gameState = 'menu';
			LK.setTimeout(function () {
				createMainMenu();
			}, 2000);
		}
	}
};

===================================================================
--- original.js
+++ change.js
@@ -1168,18 +1168,38 @@
 }
 function createSpiralPattern() {
 	var centerX = 1024;
 	var centerY = 450;
-	var spiralPoints = 30;
-	var maxRadius = 250;
-	for (var i = 0; i < spiralPoints; i++) {
-		var angle = i * 0.5;
-		var radius = i / spiralPoints * maxRadius;
-		var brick = new Brick(i % 5 + 1);
-		brick.x = centerX + Math.cos(angle) * radius;
-		brick.y = centerY + Math.sin(angle) * radius;
-		bricks.push(brick);
-		game.addChild(brick);
+	var brickWidth = 60;
+	var brickHeight = 35;
+	// Lion pattern - creating a stylized lion face
+	var lionPattern = [
+	// Mane (outer layer) - using brick type 6 (yellow/gold)
+	[0, 0, 0, 0, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 0, 0, 0, 0], [0, 0, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 0, 0], [0, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 0], [6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6],
+	// Face outline - using brick type 4 (yellow)
+	[6, 6, 6, 6, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 6, 6, 6, 6], [6, 6, 6, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 6, 6, 6], [6, 6, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 6, 6],
+	// Eyes area - using brick type 2 (green) for eyes, type 4 for face
+	[6, 6, 4, 4, 4, 2, 2, 4, 4, 4, 4, 4, 2, 2, 4, 4, 4, 6, 6], [6, 6, 4, 4, 4, 2, 2, 4, 4, 4, 4, 4, 2, 2, 4, 4, 4, 6, 6],
+	// Nose area - using brick type 1 (pink/red) for nose
+	[6, 6, 4, 4, 4, 4, 4, 4, 1, 1, 1, 4, 4, 4, 4, 4, 4, 6, 6], [6, 6, 4, 4, 4, 4, 4, 4, 1, 1, 1, 4, 4, 4, 4, 4, 4, 6, 6],
+	// Mouth area - using brick type 3 (purple) for mouth
+	[6, 6, 4, 4, 4, 4, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 6, 6], [6, 6, 4, 4, 4, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 6, 6],
+	// Lower face and chin
+	[6, 6, 6, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 6, 6, 6], [6, 6, 6, 6, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 6, 6, 6, 6],
+	// Bottom mane
+	[0, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 0], [0, 0, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 0, 0], [0, 0, 0, 0, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 0, 0, 0, 0]];
+	// Create bricks based on the lion pattern
+	for (var row = 0; row < lionPattern.length; row++) {
+		for (var col = 0; col < lionPattern[row].length; col++) {
+			if (lionPattern[row][col] > 0) {
+				var brickType = lionPattern[row][col];
+				var brick = new Brick(brickType);
+				brick.x = centerX + (col - 9) * brickWidth;
+				brick.y = centerY + (row - 8) * brickHeight - 100;
+				bricks.push(brick);
+				game.addChild(brick);
+			}
+		}
 	}
 }
 function createRandomPattern() {
 	var brickCount = 80;