===================================================================
--- original.js
+++ change.js
@@ -1,6 +1,583 @@
-/****
+/**** 
+* Plugins
+****/ 
+var tween = LK.import("@upit/tween.v1");
+var storage = LK.import("@upit/storage.v1", {
+	highScore: 0
+});
+
+/**** 
+* Classes
+****/ 
+var Building = Container.expand(function () {
+	var self = Container.call(this);
+	var types = ['building1', 'building2', 'building3'];
+	var type = types[Math.floor(Math.random() * types.length)];
+	var buildingSprite = self.attachAsset(type, {
+		anchorX: 0.5,
+		anchorY: 0
+	});
+	self.width = buildingSprite.width;
+	self.height = buildingSprite.height;
+	self.speed = Math.random() * 0.5 + 0.5; // Buildings move at different speeds for parallax effect
+	self.update = function () {
+		self.y += gameSpeed * self.speed;
+		if (self.y > 2732 + self.height) {
+			self.resetPosition();
+		}
+	};
+	self.resetPosition = function () {
+		self.y = -self.height - Math.random() * 300;
+		self.x = Math.random() * 2048;
+	};
+	return self;
+});
+var Coin = Container.expand(function () {
+	var self = Container.call(this);
+	var coinSprite = self.attachAsset('coin', {
+		anchorX: 0.5,
+		anchorY: 0.5
+	});
+	self.width = coinSprite.width;
+	self.height = coinSprite.height;
+	self.lane = 1;
+	// Coin animation (rotate)
+	LK.setInterval(function () {
+		tween(coinSprite, {
+			rotation: coinSprite.rotation + Math.PI * 2
+		}, {
+			duration: 1000
+		});
+	}, 1000);
+	self.update = function () {
+		self.y += gameSpeed;
+		if (self.y > 2732 + self.height) {
+			self.destroy();
+		}
+	};
+	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.lane = 1;
+	self.type = "normal"; // normal, low, high
+	self.setType = function (newType) {
+		self.type = newType;
+		if (newType === "low") {
+			obstacleSprite.scaleY = 0.5;
+			obstacleSprite.y = obstacleSprite.height / 4;
+		} else if (newType === "high") {
+			obstacleSprite.scaleY = 0.7;
+			obstacleSprite.y = -obstacleSprite.height / 4;
+		}
+	};
+	self.update = function () {
+		self.y += gameSpeed;
+		if (self.y > 2732 + self.height) {
+			self.destroy();
+		}
+	};
+	return self;
+});
+var Player = Container.expand(function () {
+	var self = Container.call(this);
+	var playerSprite = self.attachAsset('player', {
+		anchorX: 0.5,
+		anchorY: 0.5
+	});
+	self.width = playerSprite.width;
+	self.height = playerSprite.height;
+	self.lane = 1; // 0=left, 1=center, 2=right
+	self.isJumping = false;
+	self.isSliding = false;
+	self.hasShield = false;
+	self.jump = function () {
+		if (!self.isJumping) {
+			self.isJumping = true;
+			var startY = self.y;
+			LK.getSound('jump').play();
+			tween(self, {
+				y: startY - 300
+			}, {
+				duration: 400,
+				easing: tween.easeOut,
+				onFinish: function onFinish() {
+					tween(self, {
+						y: startY
+					}, {
+						duration: 400,
+						easing: tween.easeIn,
+						onFinish: function onFinish() {
+							self.isJumping = false;
+						}
+					});
+				}
+			});
+		}
+	};
+	self.slide = function () {
+		if (!self.isSliding && !self.isJumping) {
+			self.isSliding = true;
+			var originalHeight = playerSprite.height;
+			tween(playerSprite, {
+				scaleY: 0.5
+			}, {
+				duration: 300,
+				onFinish: function onFinish() {
+					LK.setTimeout(function () {
+						tween(playerSprite, {
+							scaleY: 1
+						}, {
+							duration: 300,
+							onFinish: function onFinish() {
+								self.isSliding = false;
+							}
+						});
+					}, 300);
+				}
+			});
+		}
+	};
+	self.moveLane = function (targetLane) {
+		if (targetLane >= 0 && targetLane <= 2) {
+			self.lane = targetLane;
+			var lanePositions = [self.width, 2048 / 2, 2048 - self.width];
+			tween(self, {
+				x: lanePositions[targetLane]
+			}, {
+				duration: 200,
+				easing: tween.easeOut
+			});
+		}
+	};
+	self.activateShield = function () {
+		self.hasShield = true;
+		playerSprite.tint = 0x00FFFF;
+		LK.setTimeout(function () {
+			self.hasShield = false;
+			playerSprite.tint = 0xFFFFFF;
+		}, 5000);
+	};
+	self.update = function () {
+		// Player logic updated in game update
+	};
+	return self;
+});
+var PowerUp = Container.expand(function () {
+	var self = Container.call(this);
+	var powerupSprite = self.attachAsset('powerup', {
+		anchorX: 0.5,
+		anchorY: 0.5
+	});
+	self.width = powerupSprite.width;
+	self.height = powerupSprite.height;
+	self.lane = 1;
+	self.type = "shield"; // shield, magnet, slowdown
+	// Pulsate animation
+	function pulsate() {
+		tween(powerupSprite, {
+			scaleX: 1.2,
+			scaleY: 1.2
+		}, {
+			duration: 500,
+			onFinish: function onFinish() {
+				tween(powerupSprite, {
+					scaleX: 1,
+					scaleY: 1
+				}, {
+					duration: 500,
+					onFinish: pulsate
+				});
+			}
+		});
+	}
+	pulsate();
+	self.setType = function (newType) {
+		self.type = newType;
+		if (newType === "shield") {
+			powerupSprite.tint = 0x00FFFF;
+		} else if (newType === "magnet") {
+			powerupSprite.tint = 0xFF00FF;
+		} else if (newType === "slowdown") {
+			powerupSprite.tint = 0x00FF00;
+		}
+	};
+	self.update = function () {
+		self.y += gameSpeed;
+		if (self.y > 2732 + self.height) {
+			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 buildings = [];
+var ground;
+var gameSpeed = 5;
+var initialGameSpeed = 5;
+var maxGameSpeed = 15;
+var speedIncreaseInterval;
+var gameStarted = false;
+var distanceTraveled = 0;
+var score = 0;
+var coinValue = 10;
+var highScore = storage.highScore || 0;
+var hasMagnet = false;
+var magnetRange = 200;
+// Lane positions
+var laneX = [player ? player.width : 150, 2048 / 2, 2048 - (player ? player.width : 150)];
+// UI elements
+var scoreTxt = new Text2('SCORE: 0', {
+	size: 60,
+	fill: 0xFFFFFF
+});
+scoreTxt.anchor.set(0, 0);
+LK.gui.topRight.addChild(scoreTxt);
+scoreTxt.x = -scoreTxt.width - 20;
+scoreTxt.y = 20;
+var distanceTxt = new Text2('DISTANCE: 0m', {
+	size: 60,
+	fill: 0xFFFFFF
+});
+distanceTxt.anchor.set(0, 0);
+LK.gui.topRight.addChild(distanceTxt);
+distanceTxt.x = -distanceTxt.width - 20;
+distanceTxt.y = 90;
+var highScoreTxt = new Text2('BEST: ' + highScore, {
+	size: 50,
+	fill: 0xFFFFFF
+});
+highScoreTxt.anchor.set(0, 0);
+LK.gui.topRight.addChild(highScoreTxt);
+highScoreTxt.x = -highScoreTxt.width - 20;
+highScoreTxt.y = 160;
+var startTxt = new Text2('SWIPE TO START', {
+	size: 100,
+	fill: 0xFFFFFF
+});
+startTxt.anchor.set(0.5, 0.5);
+LK.gui.center.addChild(startTxt);
+// Game initialization functions
+function initializeGame() {
+	// Create ground
+	ground = game.addChild(LK.getAsset('ground', {
+		anchorX: 0.5,
+		anchorY: 0.5
+	}));
+	ground.x = 2048 / 2;
+	ground.y = 2732 - ground.height / 2;
+	// Create player
+	player = game.addChild(new Player());
+	player.x = 2048 / 2;
+	player.y = 2732 - ground.height - player.height / 2;
+	// Create background buildings
+	for (var i = 0; i < 10; i++) {
+		var building = new Building();
+		building.x = Math.random() * 2048;
+		building.y = Math.random() * 2732 - 2732; // Position above screen initially
+		buildings.push(building);
+		game.addChild(building);
+	}
+	// Initialize variables
+	obstacles = [];
+	coins = [];
+	powerups = [];
+	gameSpeed = initialGameSpeed;
+	distanceTraveled = 0;
+	score = 0;
+	updateUI();
+}
+function startGame() {
+	gameStarted = true;
+	LK.setScore(0);
+	startTxt.visible = false;
+	// Start increasing game speed over time
+	speedIncreaseInterval = LK.setInterval(function () {
+		if (gameSpeed < maxGameSpeed) {
+			gameSpeed += 0.5;
+		}
+	}, 10000);
+	// Start spawning obstacles, coins, and powerups
+	spawnObstacles();
+	spawnCoins();
+	spawnPowerups();
+	// Play background music
+	LK.playMusic('bgmusic');
+}
+function updateUI() {
+	scoreTxt.setText('SCORE: ' + score);
+	scoreTxt.x = -scoreTxt.width - 20;
+	var distance = Math.floor(distanceTraveled / 10);
+	distanceTxt.setText('DISTANCE: ' + distance + 'm');
+	distanceTxt.x = -distanceTxt.width - 20;
+	highScoreTxt.setText('BEST: ' + highScore);
+	highScoreTxt.x = -highScoreTxt.width - 20;
+}
+// Object spawning functions
+function spawnObstacles() {
+	var obstacleTimer = LK.setInterval(function () {
+		if (!gameStarted) return;
+		var obstacle = new Obstacle();
+		obstacle.lane = Math.floor(Math.random() * 3); // Random lane
+		obstacle.x = laneX[obstacle.lane];
+		obstacle.y = -obstacle.height;
+		// Randomize obstacle type
+		var types = ["normal", "low", "high"];
+		var randomType = types[Math.floor(Math.random() * types.length)];
+		obstacle.setType(randomType);
+		obstacles.push(obstacle);
+		game.addChild(obstacle);
+	}, 2000 - Math.min(gameSpeed * 50, 1500)); // Spawn faster as game speed increases
+}
+function spawnCoins() {
+	var coinTimer = LK.setInterval(function () {
+		if (!gameStarted) return;
+		// Random coin pattern
+		var pattern = Math.floor(Math.random() * 4);
+		if (pattern === 0) {
+			// Single coin
+			var lane = Math.floor(Math.random() * 3);
+			spawnCoin(lane);
+		} else if (pattern === 1) {
+			// Vertical line of coins
+			var lane = Math.floor(Math.random() * 3);
+			for (var i = 0; i < 3; i++) {
+				var coin = new Coin();
+				coin.lane = lane;
+				coin.x = laneX[lane];
+				coin.y = -coin.height - i * 120;
+				coins.push(coin);
+				game.addChild(coin);
+			}
+		} else if (pattern === 2) {
+			// Horizontal line of coins
+			for (var i = 0; i < 3; i++) {
+				spawnCoin(i);
+			}
+		} else {
+			// Diagonal line of coins
+			for (var i = 0; i < 3; i++) {
+				var coin = new Coin();
+				coin.lane = i;
+				coin.x = laneX[i];
+				coin.y = -coin.height - i * 120;
+				coins.push(coin);
+				game.addChild(coin);
+			}
+		}
+	}, 3000);
+}
+function spawnCoin(lane) {
+	var coin = new Coin();
+	coin.lane = lane;
+	coin.x = laneX[lane];
+	coin.y = -coin.height;
+	coins.push(coin);
+	game.addChild(coin);
+}
+function spawnPowerups() {
+	var powerupTimer = LK.setInterval(function () {
+		if (!gameStarted) return;
+		var powerup = new PowerUp();
+		powerup.lane = Math.floor(Math.random() * 3);
+		powerup.x = laneX[powerup.lane];
+		powerup.y = -powerup.height;
+		// Randomize powerup type
+		var types = ["shield", "magnet", "slowdown"];
+		var randomType = types[Math.floor(Math.random() * types.length)];
+		powerup.setType(randomType);
+		powerups.push(powerup);
+		game.addChild(powerup);
+	}, 15000); // Powerups appear less frequently
+}
+// Game mechanics functions
+function checkCollisions() {
+	// Check obstacle collisions
+	for (var i = obstacles.length - 1; i >= 0; i--) {
+		var obstacle = obstacles[i];
+		if (player.lane === obstacle.lane && !player.isJumping && player.y - player.height / 2 < obstacle.y + obstacle.height / 2 && player.y + player.height / 2 > obstacle.y - obstacle.height / 2) {
+			// Check if player can avoid by sliding under high obstacle
+			if (obstacle.type === "high" && player.isSliding) {
+				continue;
+			}
+			// Check if player can avoid by jumping over low obstacle
+			if (obstacle.type === "low" && player.isJumping) {
+				continue;
+			}
+			// Check if player has shield
+			if (player.hasShield) {
+				player.hasShield = false;
+				player.tint = 0xFFFFFF;
+				obstacles.splice(i, 1);
+				obstacle.destroy();
+				continue;
+			}
+			// Collision occurred
+			gameOver();
+			break;
+		}
+	}
+	// Check coin collections
+	for (var i = coins.length - 1; i >= 0; i--) {
+		var coin = coins[i];
+		// Regular collection
+		if (player.lane === coin.lane && Math.abs(player.y - coin.y) < (player.height + coin.height) / 2) {
+			collectCoin(coin, i);
+		}
+		// Magnet effect collection
+		else if (hasMagnet && Math.sqrt(Math.pow(player.x - coin.x, 2) + Math.pow(player.y - coin.y, 2)) < magnetRange) {
+			tween(coin, {
+				x: player.x,
+				y: player.y
+			}, {
+				duration: 200,
+				onFinish: function onFinish() {
+					collectCoin(coin, i);
+				}
+			});
+		}
+	}
+	// Check powerup collections
+	for (var i = powerups.length - 1; i >= 0; i--) {
+		var powerup = powerups[i];
+		if (player.lane === powerup.lane && Math.abs(player.y - powerup.y) < (player.height + powerup.height) / 2) {
+			// Apply powerup effect
+			if (powerup.type === "shield") {
+				player.activateShield();
+			} else if (powerup.type === "magnet") {
+				activateMagnet();
+			} else if (powerup.type === "slowdown") {
+				slowDownGame();
+			}
+			LK.getSound('powerup_collect').play();
+			score += 30;
+			LK.setScore(score);
+			updateUI();
+			powerups.splice(i, 1);
+			powerup.destroy();
+		}
+	}
+}
+function collectCoin(coin, index) {
+	LK.getSound('coin_collect').play();
+	score += coinValue;
+	LK.setScore(score);
+	if (coins[index]) {
+		coins.splice(index, 1);
+		coin.destroy();
+	}
+	updateUI();
+}
+function activateMagnet() {
+	hasMagnet = true;
+	LK.setTimeout(function () {
+		hasMagnet = false;
+	}, 10000);
+}
+function slowDownGame() {
+	var originalSpeed = gameSpeed;
+	gameSpeed = gameSpeed / 2;
+	LK.setTimeout(function () {
+		gameSpeed = originalSpeed;
+	}, 5000);
+}
+function gameOver() {
+	LK.getSound('crash').play();
+	LK.effects.flashScreen(0xFF0000, 500);
+	// Update high score if needed
+	if (score > highScore) {
+		highScore = score;
+		storage.highScore = highScore;
+	}
+	// Clear intervals
+	LK.clearInterval(speedIncreaseInterval);
+	// Show game over screen
+	LK.showGameOver();
+}
+// Touch/swipe controls
+var startY, startX;
+var MIN_SWIPE_DISTANCE = 50;
+game.down = function (x, y) {
+	startX = x;
+	startY = y;
+};
+game.up = function (x, y) {
+	if (!startX || !startY) return;
+	var deltaX = x - startX;
+	var deltaY = y - startY;
+	var absDeltaX = Math.abs(deltaX);
+	var absDeltaY = Math.abs(deltaY);
+	// Start game on any swipe if not started
+	if (!gameStarted) {
+		startGame();
+		return;
+	}
+	// Detect swipe direction
+	if (absDeltaX > MIN_SWIPE_DISTANCE || absDeltaY > MIN_SWIPE_DISTANCE) {
+		// Horizontal swipe detection (left/right)
+		if (absDeltaX > absDeltaY) {
+			if (deltaX > 0) {
+				// Swipe right
+				player.moveLane(Math.min(player.lane + 1, 2));
+			} else {
+				// Swipe left
+				player.moveLane(Math.max(player.lane - 1, 0));
+			}
+		}
+		// Vertical swipe detection (up/down)
+		else {
+			if (deltaY < 0) {
+				// Swipe up (jump)
+				player.jump();
+			} else {
+				// Swipe down (slide)
+				player.slide();
+			}
+		}
+	}
+};
+// Initialize the game
+initializeGame();
+// Game update loop
+game.update = function () {
+	if (!gameStarted) return;
+	// Update distance traveled
+	distanceTraveled += gameSpeed;
+	updateUI();
+	// Check for collisions
+	checkCollisions();
+	// Update game objects
+	for (var i = obstacles.length - 1; i >= 0; i--) {
+		if (obstacles[i]) obstacles[i].update();
+	}
+	for (var i = coins.length - 1; i >= 0; i--) {
+		if (coins[i]) coins[i].update();
+	}
+	for (var i = powerups.length - 1; i >= 0; i--) {
+		if (powerups[i]) powerups[i].update();
+	}
+	for (var i = buildings.length - 1; i >= 0; i--) {
+		if (buildings[i]) buildings[i].update();
+	}
+};
\ No newline at end of file