===================================================================
--- original.js
+++ change.js
@@ -1,6 +1,455 @@
-/****
+/**** 
+* 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 ballSprite = self.attachAsset('ball', {
+		anchorX: 0.5,
+		anchorY: 0.5
+	});
+	self.radius = ballSprite.width / 2;
+	self.velocity = {
+		x: 7,
+		y: -15
+	};
+	self.gravity = 0.5;
+	self.bounce = 0.8;
+	self.isAlive = true;
+	self.isPoweredUp = false;
+	self.update = function () {
+		if (!self.isAlive) {
+			return;
+		}
+		// Apply gravity
+		self.velocity.y += self.gravity;
+		// Move based on velocity
+		self.x += self.velocity.x;
+		self.y += self.velocity.y;
+		// Bounce off walls
+		if (self.x < self.radius) {
+			self.x = self.radius;
+			self.velocity.x = Math.abs(self.velocity.x);
+		} else if (self.x > 2048 - self.radius) {
+			self.x = 2048 - self.radius;
+			self.velocity.x = -Math.abs(self.velocity.x);
+		}
+		// Bounce off ground
+		if (self.y > 2732 - 100 - self.radius) {
+			self.y = 2732 - 100 - self.radius;
+			self.velocity.y = -Math.abs(self.velocity.y * self.bounce);
+			LK.getSound('bounce').play();
+		}
+		// Bounce off ceiling
+		if (self.y < self.radius) {
+			self.y = self.radius;
+			self.velocity.y = Math.abs(self.velocity.y * self.bounce);
+			LK.getSound('bounce').play();
+		}
+	};
+	self.changeDirection = function () {
+		if (!self.isAlive) {
+			return;
+		}
+		// Reverse horizontal direction on tap
+		self.velocity.x = -self.velocity.x;
+	};
+	self.activatePowerUp = function (type) {
+		self.isPoweredUp = true;
+		// Different power-up effects
+		if (type === "slow") {
+			var originalVelocityX = self.velocity.x;
+			var originalVelocityY = self.velocity.y;
+			var originalGravity = self.gravity;
+			// Slow down
+			self.velocity.x *= 0.5;
+			self.velocity.y *= 0.5;
+			self.gravity *= 0.5;
+			// Flash the ball to indicate power-up
+			tween(ballSprite, {
+				tint: 0x00FFFF
+			}, {
+				duration: 300,
+				easing: tween.linear
+			});
+			// Reset after 5 seconds
+			LK.setTimeout(function () {
+				self.velocity.x = originalVelocityX;
+				self.velocity.y = originalVelocityY;
+				self.gravity = originalGravity;
+				self.isPoweredUp = false;
+				tween(ballSprite, {
+					tint: 0xFFFFFF
+				}, {
+					duration: 300,
+					easing: tween.linear
+				});
+			}, 5000);
+		} else if (type === "small") {
+			var originalRadius = self.radius;
+			// Shrink the ball
+			tween(ballSprite, {
+				scale: 0.5
+			}, {
+				duration: 300,
+				easing: tween.easeOut
+			});
+			self.radius *= 0.5;
+			// Flash the ball to indicate power-up
+			tween(ballSprite, {
+				tint: 0xFF00FF
+			}, {
+				duration: 300,
+				easing: tween.linear
+			});
+			// Reset after 5 seconds
+			LK.setTimeout(function () {
+				tween(ballSprite, {
+					scale: 1
+				}, {
+					duration: 300,
+					easing: tween.easeOut
+				});
+				self.radius = originalRadius;
+				self.isPoweredUp = false;
+				tween(ballSprite, {
+					tint: 0xFFFFFF
+				}, {
+					duration: 300,
+					easing: tween.linear
+				});
+			}, 5000);
+		}
+	};
+	return self;
+});
+var Obstacle = Container.expand(function () {
+	var self = Container.call(this);
+	var obstacleSprite = self.attachAsset('obstacle', {
+		anchorX: 0.5,
+		anchorY: 0.5
+	});
+	self.width = obstacleSprite.width;
+	self.height = obstacleSprite.height;
+	self.speed = 5;
+	self.update = function () {
+		self.x -= self.speed;
+		// Remove if off screen
+		if (self.x < -self.width) {
+			self.shouldRemove = true;
+		}
+	};
+	self.setSpeed = function (newSpeed) {
+		self.speed = newSpeed;
+	};
+	return self;
+});
+var PowerUp = Container.expand(function () {
+	var self = Container.call(this);
+	var powerupSprite = self.attachAsset('powerup', {
+		anchorX: 0.5,
+		anchorY: 0.5
+	});
+	self.radius = powerupSprite.width / 2;
+	self.speed = 5;
+	self.type = Math.random() < 0.5 ? "slow" : "small";
+	// Set color based on type
+	if (self.type === "slow") {
+		powerupSprite.tint = 0x00FFFF; // Cyan for slow time
+	} else {
+		powerupSprite.tint = 0xFF00FF; // Magenta for shrink
+	}
+	self.update = function () {
+		self.x -= self.speed;
+		// Spin effect
+		powerupSprite.rotation += 0.05;
+		// Remove if off screen
+		if (self.x < -self.radius * 2) {
+			self.shouldRemove = true;
+		}
+	};
+	self.setSpeed = function (newSpeed) {
+		self.speed = newSpeed;
+	};
+	return self;
+});
+
+/**** 
 * Initialize Game
-****/
+****/ 
 var game = new LK.Game({
-	backgroundColor: 0x000000
-});
\ No newline at end of file
+	backgroundColor: 0x87CEEB
+});
+
+/**** 
+* Game Code
+****/ 
+// Game variables
+var obstacles = [];
+var powerups = [];
+var obstacleSpawnTimer = null;
+var powerupSpawnTimer = null;
+var gameSpeed = 5;
+var spawnRate = 2000;
+var score = 0;
+var difficultyTimer = null;
+var isGameActive = false;
+// Create background
+var background = game.addChild(LK.getAsset('background', {
+	anchorX: 0,
+	anchorY: 0,
+	x: 0,
+	y: 0
+}));
+// Create ground
+var ground = game.addChild(LK.getAsset('ground', {
+	anchorX: 0,
+	anchorY: 0,
+	x: 0,
+	y: 2732 - 100
+}));
+// Create ball
+var ball = game.addChild(new Ball());
+ball.x = 300;
+ball.y = 500;
+// Create score text
+var scoreTxt = new Text2('Score: 0', {
+	size: 70,
+	fill: 0xFFFFFF
+});
+scoreTxt.anchor.set(0.5, 0);
+LK.gui.top.addChild(scoreTxt);
+scoreTxt.y = 50;
+// Create high score text
+var highScore = storage.highScore || 0;
+var highScoreTxt = new Text2('Best: ' + highScore, {
+	size: 50,
+	fill: 0xFFFFFF
+});
+highScoreTxt.anchor.set(0.5, 0);
+LK.gui.top.addChild(highScoreTxt);
+highScoreTxt.y = 130;
+// Start message
+var tapToStartTxt = new Text2('Tap to Start', {
+	size: 100,
+	fill: 0xFFFFFF
+});
+tapToStartTxt.anchor.set(0.5, 0.5);
+LK.gui.center.addChild(tapToStartTxt);
+// Game functions
+function startGame() {
+	if (isGameActive) {
+		return;
+	}
+	isGameActive = true;
+	score = 0;
+	gameSpeed = 5;
+	scoreTxt.setText('Score: 0');
+	// Remove start message
+	LK.gui.center.removeChild(tapToStartTxt);
+	// Reset the ball
+	ball.x = 300;
+	ball.y = 500;
+	ball.velocity = {
+		x: 7,
+		y: -15
+	};
+	ball.isAlive = true;
+	// Clear existing obstacles and powerups
+	for (var i = obstacles.length - 1; i >= 0; i--) {
+		game.removeChild(obstacles[i]);
+	}
+	obstacles = [];
+	for (var i = powerups.length - 1; i >= 0; i--) {
+		game.removeChild(powerups[i]);
+	}
+	powerups = [];
+	// Start obstacle spawning
+	spawnRate = 2000;
+	obstacleSpawnTimer = LK.setInterval(spawnObstacle, spawnRate);
+	// Start power-up spawning (less frequent)
+	powerupSpawnTimer = LK.setInterval(spawnPowerUp, 7000);
+	// Increase difficulty over time
+	difficultyTimer = LK.setInterval(increaseDifficulty, 10000);
+	// Play background music
+	LK.playMusic('gameMusic', {
+		fade: {
+			start: 0,
+			end: 0.4,
+			duration: 1000
+		}
+	});
+}
+function gameOver() {
+	isGameActive = false;
+	ball.isAlive = false;
+	// Play crash sound
+	LK.getSound('crash').play();
+	// Flash screen red
+	LK.effects.flashScreen(0xFF0000, 500);
+	// Stop spawning
+	LK.clearInterval(obstacleSpawnTimer);
+	LK.clearInterval(powerupSpawnTimer);
+	LK.clearInterval(difficultyTimer);
+	// Update high score if needed
+	if (score > highScore) {
+		highScore = score;
+		storage.highScore = highScore;
+		highScoreTxt.setText('Best: ' + highScore);
+	}
+	// Show game over
+	LK.showGameOver();
+}
+function spawnObstacle() {
+	if (!isGameActive) {
+		return;
+	}
+	var obstacle = new Obstacle();
+	// Random height
+	var height = 200 + Math.random() * 300;
+	obstacle.getChildAt(0).height = height;
+	obstacle.height = height;
+	// Position at right side of screen
+	obstacle.x = 2048 + obstacle.width / 2;
+	// Random vertical position, but ensure gap for player
+	var minY = 150;
+	var maxY = 2732 - 100 - 150 - height;
+	obstacle.y = minY + Math.random() * (maxY - minY);
+	// Set speed
+	obstacle.setSpeed(gameSpeed);
+	// Add to game
+	obstacles.push(obstacle);
+	game.addChild(obstacle);
+}
+function spawnPowerUp() {
+	if (!isGameActive) {
+		return;
+	}
+	var powerup = new PowerUp();
+	// Position at right side of screen
+	powerup.x = 2048 + powerup.radius;
+	// Random vertical position
+	powerup.y = 150 + Math.random() * (2732 - 350);
+	// Set speed
+	powerup.setSpeed(gameSpeed);
+	// Add to game
+	powerups.push(powerup);
+	game.addChild(powerup);
+}
+function increaseDifficulty() {
+	if (!isGameActive) {
+		return;
+	}
+	// Increase game speed
+	gameSpeed += 0.5;
+	// Update existing obstacles and powerups
+	for (var i = 0; i < obstacles.length; i++) {
+		obstacles[i].setSpeed(gameSpeed);
+	}
+	for (var i = 0; i < powerups.length; i++) {
+		powerups[i].setSpeed(gameSpeed);
+	}
+	// Decrease spawn rate (but not below 1000ms)
+	spawnRate = Math.max(1000, spawnRate - 100);
+	// Clear and reset obstacle spawn timer with new rate
+	LK.clearInterval(obstacleSpawnTimer);
+	obstacleSpawnTimer = LK.setInterval(spawnObstacle, spawnRate);
+}
+function checkCollisions() {
+	if (!ball.isAlive) {
+		return;
+	}
+	// Check obstacle collisions
+	for (var i = obstacles.length - 1; i >= 0; i--) {
+		var obstacle = obstacles[i];
+		// Simple rectangle collision detection
+		var ballLeft = ball.x - ball.radius;
+		var ballRight = ball.x + ball.radius;
+		var ballTop = ball.y - ball.radius;
+		var ballBottom = ball.y + ball.radius;
+		var obstacleLeft = obstacle.x - obstacle.width / 2;
+		var obstacleRight = obstacle.x + obstacle.width / 2;
+		var obstacleTop = obstacle.y - obstacle.height / 2;
+		var obstacleBottom = obstacle.y + obstacle.height / 2;
+		if (ballRight > obstacleLeft && ballLeft < obstacleRight && ballBottom > obstacleTop && ballTop < obstacleBottom) {
+			// If powered up with "small", do more precise collision detection
+			if (ball.isPoweredUp && ball.radius < 25) {
+				// More precise circle-rectangle collision
+				var closestX = Math.max(obstacleLeft, Math.min(ball.x, obstacleRight));
+				var closestY = Math.max(obstacleTop, Math.min(ball.y, obstacleBottom));
+				var distanceX = ball.x - closestX;
+				var distanceY = ball.y - closestY;
+				var distanceSquared = distanceX * distanceX + distanceY * distanceY;
+				if (distanceSquared < ball.radius * ball.radius) {
+					gameOver();
+					return;
+				}
+			} else {
+				gameOver();
+				return;
+			}
+		}
+	}
+	// Check powerup collisions
+	for (var i = powerups.length - 1; i >= 0; i--) {
+		var powerup = powerups[i];
+		// Simple circle collision detection
+		var dx = ball.x - powerup.x;
+		var dy = ball.y - powerup.y;
+		var distance = Math.sqrt(dx * dx + dy * dy);
+		if (distance < ball.radius + powerup.radius) {
+			// Collect powerup
+			LK.getSound('collect').play();
+			// Apply powerup effect
+			ball.activatePowerUp(powerup.type);
+			// Remove powerup
+			game.removeChild(powerup);
+			powerups.splice(i, 1);
+			// Add score
+			score += 10;
+			scoreTxt.setText('Score: ' + score);
+		}
+	}
+}
+function updateGame() {
+	if (!isGameActive) {
+		return;
+	}
+	// Update obstacles
+	for (var i = obstacles.length - 1; i >= 0; i--) {
+		if (obstacles[i].shouldRemove) {
+			game.removeChild(obstacles[i]);
+			obstacles.splice(i, 1);
+			// Increment score when passing an obstacle
+			score += 1;
+			scoreTxt.setText('Score: ' + score);
+			continue;
+		}
+	}
+	// Update powerups
+	for (var i = powerups.length - 1; i >= 0; i--) {
+		if (powerups[i].shouldRemove) {
+			game.removeChild(powerups[i]);
+			powerups.splice(i, 1);
+		}
+	}
+	// Check for collisions
+	checkCollisions();
+}
+// Event handlers
+game.down = function (x, y, obj) {
+	if (!isGameActive) {
+		startGame();
+	} else {
+		ball.changeDirection();
+	}
+};
+// Main update function
+game.update = function () {
+	updateGame();
+};
\ No newline at end of file