===================================================================
--- original.js
+++ change.js
@@ -1,6 +1,544 @@
-/****
+/**** 
+* Plugins
+****/ 
+var tween = LK.import("@upit/tween.v1");
+var storage = LK.import("@upit/storage.v1", {
+	highScore: 0,
+	gems: 0,
+	avatarColor: 16754176
+});
+
+/**** 
+* Classes
+****/ 
+var BackgroundFire = Container.expand(function () {
+	var self = Container.call(this);
+	self.speed = -3; // Slower than game elements for parallax effect
+	var fireGraphics = self.attachAsset('backgroundFire', {
+		anchorX: 0.5,
+		anchorY: 1.0,
+		alpha: 0.7
+	});
+	// Randomize initial scale
+	var scale = 0.5 + Math.random() * 1.0;
+	fireGraphics.scale.set(scale, scale);
+	// Animation variables
+	self.waveTime = Math.random() * Math.PI * 2; // Random start phase
+	self.update = function () {
+		self.x += self.speed;
+		// Create fire wave effect
+		self.waveTime += 0.1;
+		var waveScale = Math.sin(self.waveTime) * 0.2;
+		fireGraphics.scaleX = scale + waveScale;
+		fireGraphics.scaleY = scale - waveScale / 2;
+		// Remove if off screen
+		if (self.x < -fireGraphics.width) {
+			self.destroy();
+		}
+	};
+	return self;
+});
+var Gem = Container.expand(function () {
+	var self = Container.call(this);
+	self.speed = -12;
+	self.collected = false;
+	var gemGraphics = self.attachAsset('gem', {
+		anchorX: 0.5,
+		anchorY: 0.5
+	});
+	// Add pulsing animation
+	self.pulseTime = 0;
+	self.update = function () {
+		self.x += self.speed;
+		// Pulsing animation
+		self.pulseTime += 0.1;
+		var scale = 0.9 + Math.sin(self.pulseTime) * 0.1;
+		gemGraphics.scale.set(scale, scale);
+		// Remove if off screen
+		if (self.x < -100) {
+			self.destroy();
+		}
+	};
+	self.collect = function () {
+		if (self.collected) {
+			return;
+		}
+		self.collected = true;
+		LK.getSound('collect').play();
+		// Animate gem collection
+		tween(gemGraphics, {
+			alpha: 0,
+			scaleX: 2,
+			scaleY: 2
+		}, {
+			duration: 300,
+			onFinish: function onFinish() {
+				self.destroy();
+			}
+		});
+		// Update game stats
+		storage.gems = (storage.gems || 0) + 1;
+	};
+	return self;
+});
+var Obstacle = Container.expand(function () {
+	var self = Container.call(this);
+	self.speed = -12;
+	self.type = 'standard'; // standard, spikes, moving
+	var obstacleGraphics = self.attachAsset('obstacle', {
+		anchorX: 0.5,
+		anchorY: 0.5
+	});
+	self.setType = function (newType) {
+		self.type = newType;
+		if (newType === 'spikes') {
+			obstacleGraphics = self.removeChild(obstacleGraphics);
+			obstacleGraphics = self.attachAsset('spikes', {
+				anchorX: 0.5,
+				anchorY: 0.5
+			});
+		} else if (newType === 'moving') {
+			// Add a slight tint to show it's a moving obstacle
+			obstacleGraphics.tint = 0xff9900;
+			// Start movement animation
+			self.startY = self.y;
+			self.moveRange = 150;
+			self.moveSpeed = 0.05;
+			self.moveTime = 0;
+		}
+	};
+	self.update = function () {
+		self.x += self.speed;
+		// Handle moving obstacles
+		if (self.type === 'moving') {
+			self.moveTime += self.moveSpeed;
+			self.y = self.startY + Math.sin(self.moveTime) * self.moveRange;
+		}
+		// Remove if off screen
+		if (self.x < -100) {
+			self.destroy();
+		}
+	};
+	return self;
+});
+var Particle = Container.expand(function () {
+	var self = Container.call(this);
+	var particleGraphics = self.attachAsset('particle', {
+		anchorX: 0.5,
+		anchorY: 0.5,
+		alpha: 0.8
+	});
+	// Set random velocity
+	self.velocity = {
+		x: -5 + Math.random() * 10,
+		y: -10 + Math.random() * 5
+	};
+	self.gravity = 0.5;
+	self.lifetime = 30 + Math.random() * 30;
+	self.age = 0;
+	self.update = function () {
+		// Apply physics
+		self.velocity.y += self.gravity;
+		self.x += self.velocity.x;
+		self.y += self.velocity.y;
+		// Age the particle
+		self.age++;
+		// Fade out as it ages
+		particleGraphics.alpha = Math.max(0, 1 - self.age / self.lifetime);
+		// Destroy when lifetime ends
+		if (self.age >= self.lifetime) {
+			self.destroy();
+		}
+	};
+	return self;
+});
+var Platform = Container.expand(function () {
+	var self = Container.call(this);
+	self.speed = -12;
+	var platformGraphics = self.attachAsset('platform', {
+		anchorX: 0.5,
+		anchorY: 0.5
+	});
+	self.update = function () {
+		self.x += self.speed;
+		// Remove if off screen
+		if (self.x < -platformGraphics.width) {
+			self.destroy();
+		}
+	};
+	return self;
+});
+var Player = Container.expand(function () {
+	var self = Container.call(this);
+	self.velocity = {
+		x: 0,
+		y: 0
+	};
+	self.gravity = 0.8;
+	self.jumpForce = -20;
+	self.isJumping = false;
+	self.isDead = false;
+	self.isFlying = false;
+	// Get player avatar color from storage
+	var playerColor = storage.avatarColor || 0xffa600;
+	var playerGraphics = self.attachAsset('player', {
+		anchorX: 0.5,
+		anchorY: 0.5,
+		tint: playerColor
+	});
+	self.update = function () {
+		if (self.isDead) {
+			return;
+		}
+		// Apply gravity if not flying
+		if (!self.isFlying) {
+			self.velocity.y += self.gravity;
+		} else {
+			// In flying mode, go up slowly
+			self.velocity.y = -5;
+		}
+		// Apply velocity
+		self.y += self.velocity.y;
+		// Simple rotation based on velocity
+		playerGraphics.rotation += 0.05;
+		// Check floor collision
+		if (self.y > groundLevel - playerGraphics.height / 2) {
+			self.y = groundLevel - playerGraphics.height / 2;
+			self.velocity.y = 0;
+			self.isJumping = false;
+		}
+	};
+	self.jump = function () {
+		if (!self.isJumping && !self.isFlying) {
+			self.velocity.y = self.jumpForce;
+			self.isJumping = true;
+			LK.getSound('jump').play();
+		}
+	};
+	self.toggleFlying = function () {
+		self.isFlying = !self.isFlying;
+		// Change player appearance when flying
+		if (self.isFlying) {
+			tween(playerGraphics, {
+				scaleY: 0.7,
+				scaleX: 1.2
+			}, {
+				duration: 200
+			});
+		} else {
+			tween(playerGraphics, {
+				scaleY: 1,
+				scaleX: 1
+			}, {
+				duration: 200
+			});
+		}
+	};
+	self.die = function () {
+		if (self.isDead) {
+			return;
+		}
+		self.isDead = true;
+		LK.getSound('crash').play();
+		// Explosion effect
+		for (var i = 0; i < 10; i++) {
+			createParticle(self.x, self.y);
+		}
+		// Hide player
+		playerGraphics.alpha = 0;
+		// Game over after a short delay
+		LK.setTimeout(function () {
+			LK.showGameOver();
+		}, 1000);
+	};
+	return self;
+});
+
+/**** 
 * Initialize Game
-****/
+****/ 
 var game = new LK.Game({
-	backgroundColor: 0x000000
-});
\ No newline at end of file
+	backgroundColor: 0x331111 // Dark red background
+});
+
+/**** 
+* Game Code
+****/ 
+// Global variables
+var player;
+var obstacles = [];
+var gems = [];
+var platforms = [];
+var backgroundFires = [];
+var particles = [];
+var groundLevel = 2732 - 100; // Ground is 100px from bottom
+var score = 0;
+var obstacleSpeed = -12;
+var obstacleTimer = 0;
+var obstacleInterval = 120; // Frames between obstacles
+var level = 1;
+var gameStarted = false;
+var isGameOver = false;
+// Game UI elements
+var scoreText = new Text2('Score: 0', {
+	size: 80,
+	fill: 0xFFFFFF
+});
+scoreText.anchor.set(1.0, 0);
+LK.gui.topRight.addChild(scoreText);
+var levelText = new Text2('Level: 1', {
+	size: 80,
+	fill: 0xFFFFFF
+});
+levelText.anchor.set(0.0, 0);
+LK.gui.topLeft.addChild(levelText);
+// Move the level text away from the top left corner (platform menu area)
+levelText.x = 120;
+levelText.y = 20;
+var gemCountText = new Text2('Gems: ' + (storage.gems || 0), {
+	size: 60,
+	fill: 0x00FFFF
+});
+gemCountText.anchor.set(0.5, 0);
+LK.gui.top.addChild(gemCountText);
+// Create a tap to start message
+var startText = new Text2('Tap to Start', {
+	size: 120,
+	fill: 0xFFFFFF
+});
+startText.anchor.set(0.5, 0.5);
+LK.gui.center.addChild(startText);
+// Create the ground
+var ground = game.addChild(LK.getAsset('ground', {
+	anchorX: 0.5,
+	anchorY: 0.0,
+	x: 2048 / 2,
+	y: groundLevel
+}));
+// Create the player
+player = game.addChild(new Player());
+player.x = 500;
+player.y = groundLevel - 100;
+// Update the obstacle speed based on level
+function updateDifficulty() {
+	// Increase speed as level increases
+	obstacleSpeed = -12 - level;
+	// Decrease interval between obstacles as level increases
+	obstacleInterval = Math.max(60, 120 - level * 5);
+	// Update all current obstacles and platforms
+	for (var i = 0; i < obstacles.length; i++) {
+		obstacles[i].speed = obstacleSpeed;
+	}
+	for (var i = 0; i < platforms.length; i++) {
+		platforms[i].speed = obstacleSpeed;
+	}
+	for (var i = 0; i < gems.length; i++) {
+		gems[i].speed = obstacleSpeed;
+	}
+	// Update level text
+	levelText.setText('Level: ' + level);
+}
+// Create a new obstacle
+function createObstacle() {
+	var obstacle = new Obstacle();
+	obstacle.x = 2048 + 100; // Start just off-screen
+	obstacle.y = groundLevel - obstacle.height / 2;
+	obstacle.speed = obstacleSpeed;
+	// Random obstacle type
+	var type = Math.random();
+	if (type < 0.3) {
+		obstacle.setType('spikes');
+	} else if (type < 0.6 && level > 1) {
+		obstacle.setType('moving');
+		// Position moving obstacles higher so they move up and down
+		obstacle.y -= 150;
+	}
+	obstacles.push(obstacle);
+	game.addChild(obstacle);
+	// Sometimes add platforms after obstacles
+	if (Math.random() < 0.4) {
+		createPlatform(obstacle.x + 350, groundLevel - 200 - Math.random() * 150);
+	}
+	// Sometimes add gems
+	if (Math.random() < 0.3) {
+		createGem(obstacle.x + 150, obstacle.y - 150);
+	}
+}
+// Create a platform
+function createPlatform(x, y) {
+	var platform = new Platform();
+	platform.x = x || 2048 + 100; // Start just off-screen
+	platform.y = y || groundLevel - 300;
+	platform.speed = obstacleSpeed;
+	platforms.push(platform);
+	game.addChild(platform);
+}
+// Create a gem
+function createGem(x, y) {
+	var gem = new Gem();
+	gem.x = x || 2048 + 100; // Start just off-screen
+	gem.y = y || groundLevel - 200;
+	gem.speed = obstacleSpeed;
+	gems.push(gem);
+	game.addChild(gem);
+}
+// Create a background fire
+function createBackgroundFire() {
+	var fire = new BackgroundFire();
+	fire.x = 2048 + Math.random() * 500;
+	fire.y = groundLevel + 10; // Slightly below ground level
+	backgroundFires.push(fire);
+	game.addChild(fire);
+}
+// Create a particle
+function createParticle(x, y) {
+	var particle = new Particle();
+	particle.x = x;
+	particle.y = y;
+	particles.push(particle);
+	game.addChild(particle);
+}
+// Check collision between player and obstacles
+function checkCollisions() {
+	// Check obstacle collisions
+	for (var i = 0; i < obstacles.length; i++) {
+		if (player.intersects(obstacles[i]) && !player.isDead) {
+			player.die();
+			return;
+		}
+	}
+	// Check gem collections
+	for (var i = 0; i < gems.length; i++) {
+		if (!gems[i].collected && player.intersects(gems[i])) {
+			gems[i].collect();
+			score += 10;
+			updateScore();
+		}
+	}
+	// Check platform collisions
+	var onPlatform = false;
+	for (var i = 0; i < platforms.length; i++) {
+		if (player.intersects(platforms[i]) && player.y < platforms[i].y - 10 && player.velocity.y > 0) {
+			player.y = platforms[i].y - platforms[i].height / 2 - player.height / 2;
+			player.velocity.y = 0;
+			player.isJumping = false;
+			onPlatform = true;
+		}
+	}
+}
+// Update score display
+function updateScore() {
+	scoreText.setText('Score: ' + score);
+	gemCountText.setText('Gems: ' + (storage.gems || 0));
+	// Check for level up
+	if (score >= level * 100) {
+		levelUp();
+	}
+	// Update high score
+	if (score > storage.highScore) {
+		storage.highScore = score;
+	}
+}
+// Level up function
+function levelUp() {
+	level++;
+	// Flash level text
+	LK.effects.flashObject(levelText, 0xffff00, 500);
+	// Update difficulty
+	updateDifficulty();
+}
+// Start the game
+function startGame() {
+	if (gameStarted) {
+		return;
+	}
+	gameStarted = true;
+	startText.visible = false;
+	// Start background music
+	LK.playMusic('bgmusic', {
+		fade: {
+			start: 0,
+			end: 0.7,
+			duration: 1000
+		}
+	});
+	// Add initial obstacles and fire effects
+	createObstacle();
+	for (var i = 0; i < 5; i++) {
+		createBackgroundFire();
+	}
+	// Start score counter
+	scoreInterval = LK.setInterval(function () {
+		if (!player.isDead) {
+			score++;
+			updateScore();
+		}
+	}, 1000);
+}
+// Handle game input
+game.down = function (x, y, obj) {
+	if (!gameStarted) {
+		startGame();
+		return;
+	}
+	// Jump when tapping upper half of screen
+	if (y < 2732 / 2) {
+		player.jump();
+	}
+	// Toggle flying mode when tapping lower half
+	else {
+		player.toggleFlying();
+	}
+};
+// Main game update
+game.update = function () {
+	if (!gameStarted) {
+		return;
+	}
+	// Spawn obstacles at intervals
+	obstacleTimer++;
+	if (obstacleTimer >= obstacleInterval && !player.isDead) {
+		createObstacle();
+		obstacleTimer = 0;
+	}
+	// Spawn background fires
+	if (LK.ticks % 120 === 0 && !player.isDead) {
+		createBackgroundFire();
+	}
+	// Update all game elements
+	player.update();
+	for (var i = obstacles.length - 1; i >= 0; i--) {
+		obstacles[i].update();
+		if (!obstacles[i].parent) {
+			obstacles.splice(i, 1);
+		}
+	}
+	for (var i = gems.length - 1; i >= 0; i--) {
+		gems[i].update();
+		if (!gems[i].parent) {
+			gems.splice(i, 1);
+		}
+	}
+	for (var i = platforms.length - 1; i >= 0; i--) {
+		platforms[i].update();
+		if (!platforms[i].parent) {
+			platforms.splice(i, 1);
+		}
+	}
+	for (var i = backgroundFires.length - 1; i >= 0; i--) {
+		backgroundFires[i].update();
+		if (!backgroundFires[i].parent) {
+			backgroundFires.splice(i, 1);
+		}
+	}
+	for (var i = particles.length - 1; i >= 0; i--) {
+		particles[i].update();
+		if (!particles[i].parent) {
+			particles.splice(i, 1);
+		}
+	}
+	// Check collisions
+	if (!player.isDead) {
+		checkCollisions();
+	}
+};
\ No newline at end of file