===================================================================
--- original.js
+++ change.js
@@ -1,6 +1,537 @@
-/****
+/**** 
+* Plugins
+****/ 
+var tween = LK.import("@upit/tween.v1");
+var storage = LK.import("@upit/storage.v1");
+
+/**** 
+* Classes
+****/ 
+var Coin = Container.expand(function () {
+	var self = Container.call(this);
+	var coinGraphics = self.attachAsset('coin', {
+		anchorX: 0.5,
+		anchorY: 0.5
+	});
+	self.speed = 0;
+	self.init = function (speed) {
+		self.speed = speed || 10;
+		// Add rotating animation
+		tween(coinGraphics, {
+			rotation: Math.PI * 2
+		}, {
+			duration: 1500,
+			onFinish: function onFinish() {
+				coinGraphics.rotation = 0;
+				self.init(self.speed);
+			}
+		});
+	};
+	self.update = function () {
+		self.x -= self.speed;
+		// Remove if off screen
+		if (self.x < -coinGraphics.width) {
+			self.destroy();
+		}
+	};
+	return self;
+});
+var Ground = Container.expand(function () {
+	var self = Container.call(this);
+	var groundGraphics = self.attachAsset('ground', {
+		anchorX: 0,
+		anchorY: 0
+	});
+	return self;
+});
+var Obstacle = Container.expand(function () {
+	var self = Container.call(this);
+	var obstacleGraphics = self.attachAsset('obstacle', {
+		anchorX: 0.5,
+		anchorY: 0.5
+	});
+	self.speed = 0;
+	self.type = "normal"; // normal, low, high
+	self.init = function (type, speed) {
+		self.type = type || "normal";
+		self.speed = speed || 10;
+		// Adjust obstacle appearance based on type
+		if (self.type === "low") {
+			obstacleGraphics.scaleY = 0.5;
+			obstacleGraphics.y = obstacleGraphics.height * 0.25;
+		} else if (self.type === "high") {
+			obstacleGraphics.y = -obstacleGraphics.height * 0.5;
+		}
+	};
+	self.update = function () {
+		self.x -= self.speed;
+		// Remove if off screen
+		if (self.x < -obstacleGraphics.width) {
+			self.destroy();
+		}
+	};
+	return self;
+});
+var Player = Container.expand(function () {
+	var self = Container.call(this);
+	var playerGraphics = self.attachAsset('player', {
+		anchorX: 0.5,
+		anchorY: 0.5
+	});
+	self.vSpeed = 0;
+	self.gravity = 0.8;
+	self.jumpPower = -20;
+	self.onGround = false;
+	self.isSliding = false;
+	self.isDashing = false;
+	self.slideTimer = 0;
+	self.dashTimer = 0;
+	self.isDoubleJumpEnabled = false;
+	self.hasDoubleJumped = false;
+	self.isInvincible = false;
+	self.invincibleTimer = 0;
+	self.jump = function () {
+		if (self.onGround) {
+			self.vSpeed = self.jumpPower;
+			self.onGround = false;
+			LK.getSound('jump').play();
+		} else if (self.isDoubleJumpEnabled && !self.hasDoubleJumped) {
+			self.vSpeed = self.jumpPower * 0.8;
+			self.hasDoubleJumped = true;
+			LK.getSound('jump').play();
+		}
+	};
+	self.slide = function () {
+		if (!self.isSliding && self.onGround) {
+			self.isSliding = true;
+			self.slideTimer = 45; // 45 frames = 0.75 seconds at 60fps
+			// Make player half height when sliding
+			tween(playerGraphics, {
+				scaleY: 0.5,
+				y: playerGraphics.height * 0.25
+			}, {
+				duration: 200,
+				easing: tween.easeOut
+			});
+		}
+	};
+	self.dash = function () {
+		if (!self.isDashing) {
+			self.isDashing = true;
+			self.dashTimer = 20; // 20 frames = 0.33 seconds at 60fps
+			LK.getSound('powerup_collect').play();
+		}
+	};
+	self.applyDoubleJump = function () {
+		self.isDoubleJumpEnabled = true;
+		self.hasDoubleJumped = false;
+	};
+	self.applyInvincibility = function () {
+		self.isInvincible = true;
+		self.invincibleTimer = 300; // 5 seconds
+		// Flash effect for invincibility
+		var flashInterval = LK.setInterval(function () {
+			playerGraphics.alpha = playerGraphics.alpha === 1 ? 0.4 : 1;
+		}, 100);
+		LK.setTimeout(function () {
+			LK.clearInterval(flashInterval);
+			playerGraphics.alpha = 1;
+		}, 5000);
+	};
+	self.resetSlide = function () {
+		self.isSliding = false;
+		tween(playerGraphics, {
+			scaleY: 1,
+			y: 0
+		}, {
+			duration: 200,
+			easing: tween.easeOut
+		});
+	};
+	self.update = function () {
+		// Apply gravity
+		self.vSpeed += self.gravity;
+		self.y += self.vSpeed;
+		// Handle collision with ground
+		if (self.y > groundY - playerGraphics.height / 2) {
+			self.y = groundY - playerGraphics.height / 2;
+			self.vSpeed = 0;
+			self.onGround = true;
+			self.hasDoubleJumped = false;
+		}
+		// Handle slide timer
+		if (self.isSliding) {
+			self.slideTimer--;
+			if (self.slideTimer <= 0) {
+				self.resetSlide();
+			}
+		}
+		// Handle dash timer
+		if (self.isDashing) {
+			self.dashTimer--;
+			if (self.dashTimer <= 0) {
+				self.isDashing = false;
+			}
+		}
+		// Handle invincibility timer
+		if (self.isInvincible) {
+			self.invincibleTimer--;
+			if (self.invincibleTimer <= 0) {
+				self.isInvincible = false;
+			}
+		}
+		// Keep player within bounds
+		if (self.x < 200) {
+			self.x = 200;
+		}
+		if (self.x > 800) {
+			self.x = 800;
+		}
+	};
+	return self;
+});
+var PowerUp = Container.expand(function () {
+	var self = Container.call(this);
+	var powerupGraphics = self.attachAsset('powerup', {
+		anchorX: 0.5,
+		anchorY: 0.5
+	});
+	self.speed = 0;
+	self.type = "doubleJump"; // doubleJump or invincibility
+	self.init = function (type, speed) {
+		self.type = type || "doubleJump";
+		self.speed = speed || 10;
+		// Different colors for different powerups
+		if (self.type === "doubleJump") {
+			powerupGraphics.tint = 0x9b59b6; // Purple
+		} else if (self.type === "invincibility") {
+			powerupGraphics.tint = 0xf39c12; // Orange
+		}
+		// Add floating animation
+		tween(self, {
+			y: self.y - 20
+		}, {
+			duration: 800,
+			easing: tween.easeInOut,
+			onFinish: function onFinish() {
+				tween(self, {
+					y: self.y + 20
+				}, {
+					duration: 800,
+					easing: tween.easeInOut,
+					onFinish: function onFinish() {
+						if (!self.destroyed) {
+							self.init(self.type, self.speed);
+						}
+					}
+				});
+			}
+		});
+	};
+	self.update = function () {
+		self.x -= self.speed;
+		// Remove if off screen
+		if (self.x < -powerupGraphics.width) {
+			self.destroyed = true;
+			self.destroy();
+		}
+	};
+	return self;
+});
+
+/**** 
 * Initialize Game
-****/
+****/ 
 var game = new LK.Game({
-	backgroundColor: 0x000000
-});
\ No newline at end of file
+	backgroundColor: 0x87CEEB // Sky blue background
+});
+
+/**** 
+* Game Code
+****/ 
+// Game variables
+var player;
+var obstacles = [];
+var coins = [];
+var powerups = [];
+var ground;
+var groundY;
+var gameSpeed = 10;
+var gameStarted = false;
+var score = 0;
+var distance = 0;
+var coinCount = 0;
+var spawnTimer = 0;
+var speedIncreaseTimer = 0;
+var lastSpawnType = "";
+// Setup UI
+var scoreTxt = new Text2('Score: 0', {
+	size: 60,
+	fill: 0xFFFFFF
+});
+scoreTxt.anchor.set(0, 0);
+LK.gui.topRight.addChild(scoreTxt);
+var coinsTxt = new Text2('Coins: 0', {
+	size: 60,
+	fill: 0xFFFFFF
+});
+coinsTxt.anchor.set(0, 0);
+coinsTxt.y = 70;
+LK.gui.topRight.addChild(coinsTxt);
+var promptTxt = new Text2('Tap to Start', {
+	size: 100,
+	fill: 0xFFFFFF
+});
+promptTxt.anchor.set(0.5, 0.5);
+LK.gui.center.addChild(promptTxt);
+// Initialize game elements
+function initGame() {
+	// Create ground
+	ground = new Ground();
+	ground.y = 2732 - 100; // Position at bottom of screen
+	game.addChild(ground);
+	groundY = ground.y;
+	// Create player
+	player = new Player();
+	player.x = 400;
+	player.y = groundY - 75;
+	game.addChild(player);
+	// Reset game variables
+	gameSpeed = 10;
+	obstacles = [];
+	coins = [];
+	powerups = [];
+	score = 0;
+	distance = 0;
+	coinCount = 0;
+	spawnTimer = 0;
+	speedIncreaseTimer = 0;
+	// Update UI
+	updateScore();
+	updateCoins();
+	// Play background music
+	LK.playMusic('bgmusic', {
+		loop: true,
+		fade: {
+			start: 0,
+			end: 0.4,
+			duration: 1000
+		}
+	});
+}
+// Start the game
+function startGame() {
+	gameStarted = true;
+	promptTxt.visible = false;
+}
+// Update score display
+function updateScore() {
+	scoreTxt.setText('Score: ' + Math.floor(score));
+}
+// Update coin display
+function updateCoins() {
+	coinsTxt.setText('Coins: ' + coinCount);
+}
+// Spawn obstacle
+function spawnObstacle() {
+	var obstacle = new Obstacle();
+	// Determine obstacle type
+	var types = ["normal", "low", "high"];
+	var type = types[Math.floor(Math.random() * types.length)];
+	// Avoid spawning same type twice in a row
+	if (type === lastSpawnType && Math.random() > 0.3) {
+		type = types[(types.indexOf(type) + 1) % types.length];
+	}
+	lastSpawnType = type;
+	obstacle.init(type, gameSpeed);
+	obstacle.x = 2048 + obstacle.width / 2;
+	obstacle.y = groundY - obstacle.height / 2;
+	game.addChild(obstacle);
+	obstacles.push(obstacle);
+}
+// Spawn coin
+function spawnCoin(x, y) {
+	var coin = new Coin();
+	coin.init(gameSpeed);
+	// If no position specified, use random position
+	if (x === undefined || y === undefined) {
+		coin.x = 2048 + coin.width / 2;
+		// Position coins at different heights
+		var heightOptions = [groundY - 200,
+		// Above ground
+		groundY - 400,
+		// Higher jump
+		groundY - 100 // Low position
+		];
+		coin.y = heightOptions[Math.floor(Math.random() * heightOptions.length)];
+	} else {
+		coin.x = x;
+		coin.y = y;
+	}
+	game.addChild(coin);
+	coins.push(coin);
+}
+// Spawn coin line
+function spawnCoinLine() {
+	var baseX = 2048 + 50;
+	var baseY = groundY - 200 - Math.random() * 200;
+	for (var i = 0; i < 5; i++) {
+		spawnCoin(baseX + i * 100, baseY);
+	}
+}
+// Spawn power-up
+function spawnPowerUp() {
+	var powerup = new PowerUp();
+	// Randomly choose power-up type
+	var type = Math.random() > 0.5 ? "doubleJump" : "invincibility";
+	powerup.init(type, gameSpeed);
+	powerup.x = 2048 + powerup.width / 2;
+	powerup.y = groundY - 300 - Math.random() * 100;
+	game.addChild(powerup);
+	powerups.push(powerup);
+}
+// Handle player collision with obstacles
+function checkCollisions() {
+	// Check obstacle collisions
+	for (var i = obstacles.length - 1; i >= 0; i--) {
+		var obstacle = obstacles[i];
+		if (player.intersects(obstacle) && !player.isInvincible) {
+			// Game over
+			LK.getSound('crash').play();
+			LK.effects.flashScreen(0xff0000, 500);
+			LK.setScore(Math.floor(score));
+			LK.showGameOver();
+			return;
+		}
+	}
+	// Check coin collisions
+	for (var j = coins.length - 1; j >= 0; j--) {
+		var coin = coins[j];
+		if (player.intersects(coin)) {
+			// Collect coin
+			LK.getSound('coin_collect').play();
+			coinCount++;
+			score += 10;
+			updateCoins();
+			updateScore();
+			coin.destroy();
+			coins.splice(j, 1);
+		}
+	}
+	// Check power-up collisions
+	for (var k = powerups.length - 1; k >= 0; k--) {
+		var powerup = powerups[k];
+		if (player.intersects(powerup)) {
+			// Apply power-up effect
+			LK.getSound('powerup_collect').play();
+			if (powerup.type === "doubleJump") {
+				player.applyDoubleJump();
+			} else if (powerup.type === "invincibility") {
+				player.applyInvincibility();
+			}
+			score += 25;
+			updateScore();
+			powerup.destroyed = true;
+			powerup.destroy();
+			powerups.splice(k, 1);
+		}
+	}
+}
+// Handle player input
+game.down = function (x, y, obj) {
+	if (!gameStarted) {
+		startGame();
+		return;
+	}
+	// Detect tap position
+	if (y < groundY - 400) {
+		// Upper screen - Jump
+		player.jump();
+	} else if (y > groundY - 200) {
+		// Lower screen - Slide
+		player.slide();
+	} else {
+		// Middle screen - Dash
+		player.dash();
+	}
+};
+// Update game state
+game.update = function () {
+	if (!gameStarted) {
+		if (!ground) {
+			initGame();
+		}
+		return;
+	}
+	// Update player
+	player.update();
+	// Update all obstacles
+	for (var i = obstacles.length - 1; i >= 0; i--) {
+		obstacles[i].update();
+		// Remove if destroyed
+		if (obstacles[i].destroyed) {
+			obstacles.splice(i, 1);
+		}
+	}
+	// Update all coins
+	for (var j = coins.length - 1; j >= 0; j--) {
+		coins[j].update();
+		// Remove if destroyed
+		if (coins[j].destroyed) {
+			coins.splice(j, 1);
+		}
+	}
+	// Update all power-ups
+	for (var k = powerups.length - 1; k >= 0; k--) {
+		powerups[k].update();
+		// Remove if destroyed
+		if (powerups[k].destroyed) {
+			powerups.splice(k, 1);
+		}
+	}
+	// Check for collisions
+	checkCollisions();
+	// Spawn logic
+	spawnTimer++;
+	// Spawn obstacle every 70-100 frames (depending on game speed)
+	var spawnRate = Math.max(100 - gameSpeed, 70);
+	if (spawnTimer >= spawnRate) {
+		spawnTimer = 0;
+		// Determine what to spawn
+		var rand = Math.random();
+		if (rand < 0.6) {
+			// 60% chance for obstacle
+			spawnObstacle();
+		} else if (rand < 0.9) {
+			// 30% chance for coin line
+			spawnCoinLine();
+		} else {
+			// 10% chance for power-up
+			spawnPowerUp();
+		}
+	}
+	// Increase game speed over time
+	speedIncreaseTimer++;
+	if (speedIncreaseTimer >= 300) {
+		// Every 5 seconds
+		speedIncreaseTimer = 0;
+		gameSpeed += 0.5;
+		// Update speed of all moving objects
+		for (var o = 0; o < obstacles.length; o++) {
+			obstacles[o].speed = gameSpeed;
+		}
+		for (var c = 0; c < coins.length; c++) {
+			coins[c].speed = gameSpeed;
+		}
+		for (var p = 0; p < powerups.length; p++) {
+			powerups[p].speed = gameSpeed;
+		}
+	}
+	// Update score based on distance
+	distance += gameSpeed / 60;
+	score = distance * 10;
+	// Update score display every 10 frames
+	if (LK.ticks % 10 === 0) {
+		updateScore();
+	}
+};
\ No newline at end of file