===================================================================
--- original.js
+++ change.js
@@ -1,6 +1,630 @@
-/****
+/**** 
+* Plugins
+****/ 
+var tween = LK.import("@upit/tween.v1");
+var storage = LK.import("@upit/storage.v1", {
+	highScore: 0
+});
+
+/**** 
+* Classes
+****/ 
+var Ball = Container.expand(function () {
+	var self = Container.call(this);
+	var ballGraphics = self.attachAsset('ball', {
+		anchorX: 0.5,
+		anchorY: 0.5
+	});
+	self.radius = ballGraphics.width / 2;
+	self.speedX = 0;
+	self.speedY = 0;
+	self.active = false;
+	self.launch = function (speedX, speedY) {
+		self.speedX = speedX;
+		self.speedY = speedY;
+		self.active = true;
+	};
+	self.reset = function (paddleX, paddleY) {
+		self.x = paddleX;
+		self.y = paddleY - 30;
+		self.speedX = 0;
+		self.speedY = 0;
+		self.active = false;
+	};
+	self.update = function () {
+		if (!self.active) {
+			return;
+		}
+		// Move ball
+		self.x += self.speedX;
+		self.y += self.speedY;
+		// Handle wall collisions
+		if (self.x - self.radius <= 0 || self.x + self.radius >= 2048) {
+			self.speedX *= -1;
+			LK.getSound('hit').play();
+		}
+		if (self.y - self.radius <= 0) {
+			self.speedY *= -1;
+			LK.getSound('hit').play();
+		}
+	};
+	return self;
+});
+var Brick = Container.expand(function (type, row, column) {
+	var self = Container.call(this);
+	var assetId = 'brick';
+	if (type === 'reinforced') {
+		assetId = 'reinforcedBrick';
+	} else if (type === 'explosive') {
+		assetId = 'explosiveBrick';
+	} else if (type === 'mystery') {
+		assetId = 'mysteryBrick';
+	}
+	var brickGraphics = self.attachAsset(assetId, {
+		anchorX: 0.5,
+		anchorY: 0.5
+	});
+	self.type = type || 'normal';
+	self.width = brickGraphics.width;
+	self.height = brickGraphics.height;
+	self.row = row || 0;
+	self.column = column || 0;
+	self.health = type === 'reinforced' ? 2 : 1;
+	self.hit = function () {
+		self.health--;
+		if (self.health <= 0) {
+			return true; // Brick destroyed
+		} else {
+			// Show brick is damaged
+			tween(brickGraphics, {
+				alpha: 0.7
+			}, {
+				duration: 100,
+				onFinish: function onFinish() {
+					tween(brickGraphics, {
+						alpha: 1
+					}, {
+						duration: 100
+					});
+				}
+			});
+			return false; // Brick still alive
+		}
+	};
+	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 = paddleGraphics.width;
+	self.height = paddleGraphics.height;
+	self.moveTo = function (x) {
+		// Ensure paddle stays within screen bounds
+		var minX = self.width / 2;
+		var maxX = 2048 - self.width / 2;
+		self.x = Math.max(minX, Math.min(maxX, x));
+	};
+	return self;
+});
+var PowerUp = Container.expand(function (type) {
+	var self = Container.call(this);
+	var powerupGraphics = self.attachAsset('powerup', {
+		anchorX: 0.5,
+		anchorY: 0.5
+	});
+	self.type = type || getRandomPowerUpType();
+	self.speed = 3;
+	function getRandomPowerUpType() {
+		var types = ['multiball', 'widen', 'slow'];
+		return types[Math.floor(Math.random() * types.length)];
+	}
+	// Set color based on power-up type
+	switch (self.type) {
+		case 'multiball':
+			powerupGraphics.tint = 0xff0000; // Red
+			break;
+		case 'widen':
+			powerupGraphics.tint = 0x00ff00; // Green
+			break;
+		case 'slow':
+			powerupGraphics.tint = 0x0000ff; // Blue
+			break;
+	}
+	self.update = function () {
+		self.y += self.speed;
+	};
+	return self;
+});
+
+/**** 
 * Initialize Game
-****/
+****/ 
 var game = new LK.Game({
-	backgroundColor: 0x000000
-});
\ No newline at end of file
+	backgroundColor: 0x000055
+});
+
+/**** 
+* Game Code
+****/ 
+// Game constants
+var BRICK_SPACING = 10;
+var BRICK_ROWS_VISIBLE = 10;
+var BRICK_COLUMNS = 12;
+var SCROLL_SPEED = 0.3;
+var STARTING_LIVES = 3;
+// Game variables
+var paddle;
+var balls = [];
+var bricks = [];
+var powerups = [];
+var score = 0;
+var lives = STARTING_LIVES;
+var level = 1;
+var scrollPosition = 0;
+var highScore = storage.highScore || 0;
+var isPaused = false;
+var isGameOver = false;
+// UI elements
+var scoreTxt;
+var livesTxt;
+var levelTxt;
+var highScoreTxt;
+function initializeGame() {
+	// Reset game state
+	score = 0;
+	lives = STARTING_LIVES;
+	level = 1;
+	scrollPosition = 0;
+	isGameOver = false;
+	// Clear existing game objects
+	while (bricks.length > 0) {
+		var brick = bricks.pop();
+		brick.destroy();
+	}
+	while (balls.length > 0) {
+		var ball = balls.pop();
+		ball.destroy();
+	}
+	while (powerups.length > 0) {
+		var powerup = powerups.pop();
+		powerup.destroy();
+	}
+	if (paddle) {
+		paddle.destroy();
+	}
+	// Create paddle
+	paddle = new Paddle();
+	paddle.x = 2048 / 2;
+	paddle.y = 2732 - 100;
+	game.addChild(paddle);
+	// Create initial ball
+	createBall();
+	// Generate initial bricks
+	generateBricks();
+	// Create UI
+	createUI();
+	// Play background music
+	LK.playMusic('gameMusic', {
+		fade: {
+			start: 0,
+			end: 0.4,
+			duration: 1000
+		}
+	});
+}
+function createBall() {
+	var ball = new Ball();
+	ball.reset(paddle.x, paddle.y);
+	game.addChild(ball);
+	balls.push(ball);
+	return ball;
+}
+function createUI() {
+	// Remove existing UI if any
+	if (scoreTxt) {
+		scoreTxt.destroy();
+	}
+	if (livesTxt) {
+		livesTxt.destroy();
+	}
+	if (levelTxt) {
+		levelTxt.destroy();
+	}
+	if (highScoreTxt) {
+		highScoreTxt.destroy();
+	}
+	// Score text
+	scoreTxt = new Text2('Score: 0', {
+		size: 60,
+		fill: 0xFFFFFF
+	});
+	scoreTxt.anchor.set(0, 0);
+	scoreTxt.x = 20;
+	scoreTxt.y = 20;
+	LK.gui.addChild(scoreTxt);
+	// Lives text
+	livesTxt = new Text2('Lives: ' + lives, {
+		size: 60,
+		fill: 0xFFFFFF
+	});
+	livesTxt.anchor.set(1, 0);
+	livesTxt.x = 2048 - 20;
+	livesTxt.y = 20;
+	LK.gui.addChild(livesTxt);
+	// Level text
+	levelTxt = new Text2('Level: ' + level, {
+		size: 60,
+		fill: 0xFFFFFF
+	});
+	levelTxt.anchor.set(0.5, 0);
+	levelTxt.x = 2048 / 2;
+	levelTxt.y = 20;
+	LK.gui.addChild(levelTxt);
+	// High score text
+	highScoreTxt = new Text2('High Score: ' + highScore, {
+		size: 50,
+		fill: 0xFFFF00
+	});
+	highScoreTxt.anchor.set(0.5, 0);
+	highScoreTxt.x = 2048 / 2;
+	highScoreTxt.y = 80;
+	LK.gui.addChild(highScoreTxt);
+}
+function updateUI() {
+	scoreTxt.setText('Score: ' + score);
+	livesTxt.setText('Lives: ' + lives);
+	levelTxt.setText('Level: ' + level);
+	highScoreTxt.setText('High Score: ' + highScore);
+}
+function generateBricks() {
+	var brickWidth = 150 + BRICK_SPACING;
+	var brickHeight = 60 + BRICK_SPACING;
+	var startX = (2048 - BRICK_COLUMNS * brickWidth) / 2 + brickWidth / 2;
+	// Generate rows beyond the visible area
+	for (var row = -5; row < BRICK_ROWS_VISIBLE; row++) {
+		for (var col = 0; col < BRICK_COLUMNS; col++) {
+			// Skip some bricks for variety (more gaps at higher levels)
+			if (Math.random() < 0.1 * (level * 0.15)) {
+				continue;
+			}
+			var brickType = 'normal';
+			// Add special bricks based on probability and level
+			var specialBrickChance = Math.min(0.5, 0.05 + level * 0.02);
+			if (Math.random() < specialBrickChance) {
+				var rand = Math.random();
+				if (rand < 0.4) {
+					brickType = 'reinforced';
+				} else if (rand < 0.7) {
+					brickType = 'explosive';
+				} else {
+					brickType = 'mystery';
+				}
+			}
+			var brick = new Brick(brickType, row, col);
+			brick.x = startX + col * brickWidth;
+			brick.y = row * brickHeight;
+			game.addChild(brick);
+			bricks.push(brick);
+		}
+	}
+}
+function addNewRowOfBricks() {
+	var brickWidth = 150 + BRICK_SPACING;
+	var brickHeight = 60 + BRICK_SPACING;
+	var startX = (2048 - BRICK_COLUMNS * brickWidth) / 2 + brickWidth / 2;
+	var row = -1; // Add new row at the top
+	for (var col = 0; col < BRICK_COLUMNS; col++) {
+		// Skip some bricks for variety
+		if (Math.random() < 0.1 * (level * 0.15)) {
+			continue;
+		}
+		var brickType = 'normal';
+		// Add special bricks based on probability and level
+		var specialBrickChance = Math.min(0.5, 0.05 + level * 0.02);
+		if (Math.random() < specialBrickChance) {
+			var rand = Math.random();
+			if (rand < 0.4) {
+				brickType = 'reinforced';
+			} else if (rand < 0.7) {
+				brickType = 'explosive';
+			} else {
+				brickType = 'mystery';
+			}
+		}
+		var brick = new Brick(brickType, row, col);
+		brick.x = startX + col * brickWidth;
+		brick.y = row * brickHeight;
+		game.addChild(brick);
+		bricks.push(brick);
+	}
+}
+function scrollBricks() {
+	var brickHeight = 60 + BRICK_SPACING;
+	scrollPosition += SCROLL_SPEED * (1 + level * 0.1);
+	// When scroll position exceeds a brick height, add a new row
+	if (scrollPosition >= brickHeight) {
+		scrollPosition -= brickHeight;
+		addNewRowOfBricks();
+	}
+	// Move all bricks down
+	for (var i = 0; i < bricks.length; i++) {
+		bricks[i].y += SCROLL_SPEED * (1 + level * 0.1);
+		// Remove bricks that have gone off the bottom of the screen
+		if (bricks[i].y > 2732 + bricks[i].height) {
+			bricks[i].destroy();
+			bricks.splice(i, 1);
+			i--;
+			// Lose a life if a brick reaches the bottom
+			loseLife();
+		}
+	}
+}
+function loseLife() {
+	lives--;
+	updateUI();
+	// Flash screen red
+	LK.effects.flashScreen(0xff0000, 500);
+	if (lives <= 0) {
+		gameOver();
+	}
+}
+function gameOver() {
+	isGameOver = true;
+	// Update high score if needed
+	if (score > highScore) {
+		highScore = score;
+		storage.highScore = highScore;
+		updateUI();
+	}
+	// Show game over screen
+	LK.showGameOver();
+}
+function handleBallCollisions() {
+	for (var i = 0; i < balls.length; i++) {
+		var ball = balls[i];
+		if (!ball.active) {
+			continue;
+		}
+		// Check if ball is below the screen
+		if (ball.y > 2732 + ball.radius) {
+			ball.destroy();
+			balls.splice(i, 1);
+			i--;
+			// If no balls left, lose a life
+			if (balls.length === 0) {
+				loseLife();
+				if (!isGameOver) {
+					createBall();
+				}
+			}
+			continue;
+		}
+		// Paddle collision
+		if (ball.y + ball.radius > paddle.y - paddle.height / 2 && ball.y - ball.radius < paddle.y + paddle.height / 2 && ball.x + ball.radius > paddle.x - paddle.width / 2 && ball.x - ball.radius < paddle.x + paddle.width / 2) {
+			// Calculate bounce angle based on where ball hit the paddle
+			var relativeIntersectX = ball.x - paddle.x;
+			var normalizedRelativeIntersectionX = relativeIntersectX / (paddle.width / 2);
+			var bounceAngle = normalizedRelativeIntersectionX * (Math.PI / 3); // Max 60 degrees
+			var ballSpeed = Math.sqrt(ball.speedX * ball.speedX + ball.speedY * ball.speedY);
+			ball.speedX = ballSpeed * Math.sin(bounceAngle);
+			ball.speedY = -ballSpeed * Math.cos(bounceAngle);
+			// Ensure the ball is moving upward
+			if (ball.speedY > 0) {
+				ball.speedY *= -1;
+			}
+			// Increase speed slightly
+			var speedMultiplier = 1.01;
+			ball.speedX *= speedMultiplier;
+			ball.speedY *= speedMultiplier;
+			LK.getSound('hit').play();
+		}
+		// Brick collision
+		for (var j = 0; j < bricks.length; j++) {
+			var brick = bricks[j];
+			if (ball.x + ball.radius > brick.x - brick.width / 2 && ball.x - ball.radius < brick.x + brick.width / 2 && ball.y + ball.radius > brick.y - brick.height / 2 && ball.y - ball.radius < brick.y + brick.height / 2) {
+				// Determine collision direction
+				var dx = ball.x - brick.x;
+				var dy = ball.y - brick.y;
+				// Horizontal or vertical collision?
+				if (Math.abs(dx) / (brick.width / 2) > Math.abs(dy) / (brick.height / 2)) {
+					ball.speedX *= -1;
+				} else {
+					ball.speedY *= -1;
+				}
+				var destroyed = brick.hit();
+				if (destroyed) {
+					// Calculate points based on brick type and row
+					var points = 10;
+					switch (brick.type) {
+						case 'reinforced':
+							points = 20;
+							break;
+						case 'explosive':
+							points = 15;
+							break;
+						case 'mystery':
+							points = 25;
+							break;
+					}
+					// Higher rows worth more
+					points += Math.max(0, 5 - brick.row) * 2;
+					score += points;
+					updateUI();
+					LK.getSound('break').play();
+					// Handle special brick effects
+					if (brick.type === 'explosive') {
+						// Destroy adjacent bricks
+						handleExplosion(brick);
+					} else if (brick.type === 'mystery') {
+						// Spawn power-up
+						spawnPowerUp(brick.x, brick.y);
+					}
+					// Remove brick
+					brick.destroy();
+					bricks.splice(j, 1);
+					j--;
+				} else {
+					LK.getSound('hit').play();
+				}
+				// Only process one brick collision per frame
+				break;
+			}
+		}
+	}
+}
+function handleExplosion(brick) {
+	LK.getSound('explosion').play();
+	LK.effects.flashObject(brick, 0xffff00, 300);
+	// Define explosion radius (in grid units)
+	var explosionRadius = 1;
+	// Check all bricks
+	for (var i = bricks.length - 1; i >= 0; i--) {
+		var targetBrick = bricks[i];
+		// Calculate grid distance
+		var rowDist = Math.abs(targetBrick.row - brick.row);
+		var colDist = Math.abs(targetBrick.column - brick.column);
+		// If within explosion radius
+		if (rowDist <= explosionRadius && colDist <= explosionRadius && targetBrick !== brick) {
+			// Award points
+			score += 5;
+			// Remove brick
+			targetBrick.destroy();
+			bricks.splice(i, 1);
+		}
+	}
+	updateUI();
+}
+function spawnPowerUp(x, y) {
+	var powerup = new PowerUp();
+	powerup.x = x;
+	powerup.y = y;
+	game.addChild(powerup);
+	powerups.push(powerup);
+}
+function handlePowerUps() {
+	for (var i = powerups.length - 1; i >= 0; i--) {
+		var powerup = powerups[i];
+		powerup.update();
+		// Check if power-up is off screen
+		if (powerup.y > 2732 + 20) {
+			powerup.destroy();
+			powerups.splice(i, 1);
+			continue;
+		}
+		// Check for collision with paddle
+		if (powerup.y + 20 > paddle.y - paddle.height / 2 && powerup.y - 20 < paddle.y + paddle.height / 2 && powerup.x + 20 > paddle.x - paddle.width / 2 && powerup.x - 20 < paddle.x + paddle.width / 2) {
+			// Apply power-up effect
+			applyPowerUp(powerup.type);
+			// Remove power-up
+			powerup.destroy();
+			powerups.splice(i, 1);
+			LK.getSound('powerup').play();
+		}
+	}
+}
+function applyPowerUp(type) {
+	switch (type) {
+		case 'multiball':
+			// Add 2 more balls
+			for (var i = 0; i < 2; i++) {
+				var ball = createBall();
+				// Launch in random direction
+				var angle = Math.PI * 1.5 + (Math.random() * Math.PI - Math.PI / 2);
+				var speed = 8 + Math.random() * 2;
+				ball.launch(Math.cos(angle) * speed, Math.sin(angle) * speed);
+			}
+			break;
+		case 'widen':
+			// Make paddle wider
+			tween.stop(paddle);
+			tween(paddle, {
+				scaleX: 1.5
+			}, {
+				duration: 300,
+				onFinish: function onFinish() {
+					// Return to normal after 10 seconds
+					LK.setTimeout(function () {
+						tween(paddle, {
+							scaleX: 1
+						}, {
+							duration: 300
+						});
+					}, 10000);
+				}
+			});
+			break;
+		case 'slow':
+			// Slow down scroll speed temporarily
+			var originalScrollSpeed = SCROLL_SPEED;
+			SCROLL_SPEED *= 0.5;
+			// Return to normal after 8 seconds
+			LK.setTimeout(function () {
+				SCROLL_SPEED = originalScrollSpeed;
+			}, 8000);
+			break;
+	}
+}
+function checkLevelUp() {
+	// Level up every 1000 points
+	var newLevel = Math.floor(score / 1000) + 1;
+	if (newLevel > level) {
+		level = newLevel;
+		updateUI();
+		// Flash screen green for level up
+		LK.effects.flashScreen(0x00ff00, 500);
+	}
+}
+// Input handlers
+var isDragging = false;
+game.down = function (x, y, obj) {
+	if (isGameOver) {
+		return;
+	}
+	isDragging = true;
+	paddle.moveTo(x);
+	// Launch ball if not active
+	if (balls.length === 1 && !balls[0].active) {
+		var angle = Math.PI * 1.5 + (Math.random() * 0.4 - 0.2); // Mostly upward
+		var speed = 8 + level * 0.3; // Speed increases with level
+		balls[0].launch(Math.cos(angle) * speed, Math.sin(angle) * speed);
+	}
+};
+game.up = function (x, y, obj) {
+	isDragging = false;
+};
+game.move = function (x, y, obj) {
+	if (isDragging) {
+		paddle.moveTo(x);
+	}
+	// If ball is not active, make it follow the paddle
+	for (var i = 0; i < balls.length; i++) {
+		if (!balls[i].active) {
+			balls[i].x = paddle.x;
+		}
+	}
+};
+// Main game update loop
+game.update = function () {
+	if (isGameOver) {
+		return;
+	}
+	// Scroll bricks down
+	scrollBricks();
+	// Update balls
+	for (var i = 0; i < balls.length; i++) {
+		balls[i].update();
+	}
+	// Check collisions
+	handleBallCollisions();
+	// Handle power-ups
+	handlePowerUps();
+	// Check for level up
+	checkLevelUp();
+};
+// Initialize the game
+initializeGame();
+// Play background music
+LK.playMusic('gameMusic');
\ No newline at end of file