===================================================================
--- original.js
+++ change.js
@@ -1,6 +1,541 @@
-/****
+/**** 
+* Plugins
+****/ 
+var tween = LK.import("@upit/tween.v1");
+var storage = LK.import("@upit/storage.v1");
+
+/**** 
+* Classes
+****/ 
+var Letter = Container.expand(function (letterType) {
+	var self = Container.call(this);
+	self.letterType = letterType || 'A';
+	var assetId;
+	var textColor = "#FFFFFF";
+	switch (self.letterType) {
+		case 'A':
+			assetId = 'letterA';
+			break;
+		case 'B':
+			assetId = 'letterB';
+			break;
+		case 'C':
+			assetId = 'letterC';
+			break;
+		default:
+			assetId = 'letterA';
+	}
+	var letterGraphics = self.attachAsset(assetId, {
+		anchorX: 0.5,
+		anchorY: 0.5
+	});
+	self.value = self.letterType === 'A' ? 10 : self.letterType === 'B' ? 20 : 30;
+	self.addText = function () {
+		self.text = new Text2(self.letterType, {
+			size: 50,
+			fill: textColor
+		});
+		self.text.anchor.set(0.5, 0.5);
+		self.addChild(self.text);
+	};
+	self.collected = function () {
+		// Animation for being collected
+		tween(self, {
+			alpha: 0,
+			scaleX: 1.5,
+			scaleY: 1.5
+		}, {
+			duration: .5,
+			onFinish: function onFinish() {
+				self.destroy();
+			}
+		});
+	};
+	self.update = function () {
+		// Letters can have simple wandering behavior
+		if (Math.random() < 0.02 && !gameOver) {
+			self.x += Math.random() * 6 - 3;
+			self.y += Math.random() * 6 - 3;
+			// Keep in bounds
+			self.x = Math.max(50, Math.min(self.x, 2048 - 50));
+			self.y = Math.max(50, Math.min(self.y, 2732 - 50));
+		}
+	};
+	self.addText();
+	return self;
+});
+var Obstacle = Container.expand(function () {
+	var self = Container.call(this);
+	var obstacleGraphics = self.attachAsset('obstacle', {
+		anchorX: 0.5,
+		anchorY: 0.5
+	});
+	self.direction = Math.random() * Math.PI * 2;
+	self.speed = 2 + Math.random() * 2;
+	self.update = function () {
+		if (gameOver) {
+			return;
+		}
+		self.x += Math.cos(self.direction) * self.speed;
+		self.y += Math.sin(self.direction) * self.speed;
+		// Bounce off edges
+		if (self.x < 60) {
+			self.x = 60;
+			self.direction = Math.PI - self.direction;
+		} else if (self.x > 2048 - 60) {
+			self.x = 2048 - 60;
+			self.direction = Math.PI - self.direction;
+		}
+		if (self.y < 60) {
+			self.y = 60;
+			self.direction = -self.direction;
+		} else if (self.y > 2732 - 60) {
+			self.y = 2732 - 60;
+			self.direction = -self.direction;
+		}
+		// Rotate the obstacle
+		obstacleGraphics.rotation += 0.01;
+	};
+	// Add X text to make it clear it's an obstacle
+	self.text = new Text2('X', {
+		size: 60,
+		fill: 0xFFFFFF
+	});
+	self.text.anchor.set(0.5, 0.5);
+	self.addChild(self.text);
+	return self;
+});
+var Player = Container.expand(function () {
+	var self = Container.call(this);
+	var playerGraphics = self.attachAsset('letterF', {
+		anchorX: 0.5,
+		anchorY: 0.5
+	});
+	self.speed = 10;
+	self.size = 100;
+	self.isMoving = false;
+	self.isDragging = false;
+	self.hasPowerup = false;
+	self.powerupTimer = null;
+	self.addText = function () {
+		self.text = new Text2('F', {
+			size: 60,
+			fill: 0xFFFFFF
+		});
+		self.text.anchor.set(0.5, 0.5);
+		self.addChild(self.text);
+	};
+	self.activatePowerup = function (type) {
+		self.hasPowerup = true;
+		// Clear any existing powerup timer
+		if (self.powerupTimer) {
+			LK.clearTimeout(self.powerupTimer);
+		}
+		if (type === 'speed') {
+			self.speed = 20;
+			playerGraphics.tint = 0xffcc00;
+		} else if (type === 'magnet') {
+			playerGraphics.tint = 0x00ccff;
+		} else if (type === 'size') {
+			tween(playerGraphics, {
+				width: 130,
+				height: 130
+			}, {
+				duration: 300
+			});
+			if (self.text) {
+				tween(self.text, {
+					size: 78
+				}, {
+					duration: 300
+				});
+			}
+		}
+		// Set timeout to reset powerup
+		self.powerupTimer = LK.setTimeout(function () {
+			self.deactivatePowerup();
+		}, 5000);
+	};
+	self.deactivatePowerup = function () {
+		self.hasPowerup = false;
+		self.speed = 10;
+		playerGraphics.tint = 0xFFFFFF;
+		tween(playerGraphics, {
+			width: 100,
+			height: 100
+		}, {
+			duration: 300
+		});
+		if (self.text) {
+			tween(self.text, {
+				size: 60
+			}, {
+				duration: 300
+			});
+		}
+	};
+	self.update = function () {
+		if (self.targetX !== undefined && self.targetY !== undefined) {
+			var dx = self.targetX - self.x;
+			var dy = self.targetY - self.y;
+			var distance = Math.sqrt(dx * dx + dy * dy);
+			if (distance > self.speed) {
+				self.x += dx / distance * self.speed;
+				self.y += dy / distance * self.speed;
+				self.isMoving = true;
+			} else {
+				self.x = self.targetX;
+				self.y = self.targetY;
+				self.targetX = undefined;
+				self.targetY = undefined;
+				self.isMoving = false;
+			}
+		}
+	};
+	self.moveTo = function (x, y) {
+		self.targetX = x;
+		self.targetY = y;
+	};
+	self.addText();
+	return self;
+});
+var PowerUp = Container.expand(function (type) {
+	var self = Container.call(this);
+	self.type = type || 'speed';
+	var powerupGraphics = self.attachAsset('powerup', {
+		anchorX: 0.5,
+		anchorY: 0.5
+	});
+	if (self.type === 'speed') {
+		powerupGraphics.tint = 0xffcc00; // Yellow for speed
+	} else if (self.type === 'magnet') {
+		powerupGraphics.tint = 0x00ccff; // Blue for magnet
+	} else if (self.type === 'size') {
+		powerupGraphics.tint = 0xff00cc; // Pink for size
+	}
+	self.pulseDirection = 1;
+	self.pulseAmount = 0;
+	self.update = function () {
+		// Make the powerup pulse
+		self.pulseAmount += 0.03 * self.pulseDirection;
+		if (self.pulseAmount > 1) {
+			self.pulseAmount = 1;
+			self.pulseDirection = -1;
+		} else if (self.pulseAmount < 0) {
+			self.pulseAmount = 0;
+			self.pulseDirection = 1;
+		}
+		var scale = 1 + self.pulseAmount * 0.2;
+		self.scale.set(scale, scale);
+		// Make powerups disappear after some time
+		if (self.timeAlive === undefined) {
+			self.timeAlive = 0;
+		} else {
+			self.timeAlive++;
+			if (self.timeAlive > 600) {
+				// 10 seconds at 60fps
+				tween(self, {
+					alpha: 0
+				}, {
+					duration: 500,
+					onFinish: function onFinish() {
+						self.destroy();
+					}
+				});
+			}
+		}
+	};
+	self.collected = function () {
+		tween(self, {
+			alpha: 0,
+			scaleX: 2,
+			scaleY: 2
+		}, {
+			duration: 500,
+			onFinish: function onFinish() {
+				self.destroy();
+			}
+		});
+	};
+	return self;
+});
+
+/**** 
 * Initialize Game
-****/
+****/ 
 var game = new LK.Game({
-	backgroundColor: 0x000000
-});
\ No newline at end of file
+	backgroundColor: 0x000022
+});
+
+/**** 
+* Game Code
+****/ 
+// Game state variables
+var player;
+var letters = [];
+var obstacles = [];
+var powerups = [];
+var level = 1;
+var gameOver = false;
+var letterSpawnTimer;
+var obstacleSpawnTimer;
+var powerupSpawnTimer;
+var levelTimer;
+var scoreTxt;
+var levelTxt;
+// Initialize game
+function initGame() {
+	// Clear any existing timers
+	if (letterSpawnTimer) {
+		LK.clearInterval(letterSpawnTimer);
+	}
+	if (obstacleSpawnTimer) {
+		LK.clearInterval(obstacleSpawnTimer);
+	}
+	if (powerupSpawnTimer) {
+		LK.clearInterval(powerupSpawnTimer);
+	}
+	if (levelTimer) {
+		LK.clearTimeout(levelTimer);
+	}
+	// Reset game state
+	gameOver = false;
+	level = 1;
+	letters = [];
+	obstacles = [];
+	powerups = [];
+	LK.setScore(0);
+	// Create player
+	player = new Player();
+	player.x = 2048 / 2;
+	player.y = 2732 / 2;
+	game.addChild(player);
+	// Create UI
+	createUI();
+	// Start spawning letters
+	startSpawning();
+	// Play background music
+	LK.playMusic('bgMusic');
+}
+function createUI() {
+	// Score text
+	scoreTxt = new Text2('Score: 0', {
+		size: 80,
+		fill: 0xFFFFFF
+	});
+	scoreTxt.anchor.set(0.5, 0);
+	LK.gui.top.addChild(scoreTxt);
+	scoreTxt.y = 30;
+	// Level text
+	levelTxt = new Text2('Level: 1', {
+		size: 60,
+		fill: 0xFFFFFF
+	});
+	levelTxt.anchor.set(0.5, 0);
+	levelTxt.y = 120;
+	LK.gui.top.addChild(levelTxt);
+}
+function startSpawning() {
+	// Clear any existing timers
+	if (letterSpawnTimer) {
+		LK.clearInterval(letterSpawnTimer);
+	}
+	if (obstacleSpawnTimer) {
+		LK.clearInterval(obstacleSpawnTimer);
+	}
+	if (powerupSpawnTimer) {
+		LK.clearInterval(powerupSpawnTimer);
+	}
+	// Spawn letters
+	letterSpawnTimer = LK.setInterval(function () {
+		if (letters.length < 5 + level) {
+			spawnLetter();
+		}
+	}, 2000 - level * 100);
+	// Spawn obstacles
+	obstacleSpawnTimer = LK.setInterval(function () {
+		if (obstacles.length < level) {
+			spawnObstacle();
+		}
+	}, 5000 - level * 200);
+	// Spawn powerups (less frequently)
+	powerupSpawnTimer = LK.setInterval(function () {
+		if (Math.random() < 0.3 && powerups.length < 2) {
+			spawnPowerup();
+		}
+	}, 10000);
+	// Set timer for next level
+	levelTimer = LK.setTimeout(function () {
+		if (!gameOver) {
+			level++;
+			levelTxt.setText('Level: ' + level);
+			startSpawning(); // Restart spawning with new level settings
+		}
+	}, 30000); // Level up every 30 seconds
+}
+function spawnLetter() {
+	var letterType;
+	var rand = Math.random();
+	if (rand < 0.5) {
+		letterType = 'A';
+	} else if (rand < 0.8) {
+		letterType = 'B';
+	} else {
+		letterType = 'C';
+	}
+	var letter = new Letter(letterType);
+	// Position randomly but not too close to player or other letters
+	var validPosition = false;
+	var attempts = 0;
+	var x, y;
+	while (!validPosition && attempts < 10) {
+		x = 100 + Math.random() * (2048 - 200);
+		y = 100 + Math.random() * (2732 - 200);
+		// Check distance from player
+		var distToPlayer = Math.sqrt(Math.pow(x - player.x, 2) + Math.pow(y - player.y, 2));
+		validPosition = distToPlayer > 300;
+		// Check distance from other letters
+		for (var i = 0; i < letters.length; i++) {
+			var distToLetter = Math.sqrt(Math.pow(x - letters[i].x, 2) + Math.pow(y - letters[i].y, 2));
+			if (distToLetter < 200) {
+				validPosition = false;
+				break;
+			}
+		}
+		attempts++;
+	}
+	letter.x = x;
+	letter.y = y;
+	game.addChild(letter);
+	letters.push(letter);
+}
+function spawnObstacle() {
+	var obstacle = new Obstacle();
+	// Position at the edge of the screen
+	var side = Math.floor(Math.random() * 4);
+	switch (side) {
+		case 0:
+			// Top
+			obstacle.x = Math.random() * 2048;
+			obstacle.y = 0;
+			obstacle.direction = Math.PI / 2 + (Math.random() * Math.PI / 4 - Math.PI / 8);
+			break;
+		case 1:
+			// Right
+			obstacle.x = 2048;
+			obstacle.y = Math.random() * 2732;
+			obstacle.direction = Math.PI + (Math.random() * Math.PI / 4 - Math.PI / 8);
+			break;
+		case 2:
+			// Bottom
+			obstacle.x = Math.random() * 2048;
+			obstacle.y = 2732;
+			obstacle.direction = Math.PI * 3 / 2 + (Math.random() * Math.PI / 4 - Math.PI / 8);
+			break;
+		case 3:
+			// Left
+			obstacle.x = 0;
+			obstacle.y = Math.random() * 2732;
+			obstacle.direction = Math.random() * Math.PI / 4 - Math.PI / 8;
+			break;
+	}
+	game.addChild(obstacle);
+	obstacles.push(obstacle);
+}
+function spawnPowerup() {
+	var types = ['speed', 'magnet', 'size'];
+	var type = types[Math.floor(Math.random() * types.length)];
+	var powerup = new PowerUp(type);
+	powerup.x = 100 + Math.random() * (2048 - 200);
+	powerup.y = 100 + Math.random() * (2732 - 200);
+	game.addChild(powerup);
+	powerups.push(powerup);
+}
+function checkCollisions() {
+	// Check letter collisions
+	for (var i = letters.length - 1; i >= 0; i--) {
+		if (player.intersects(letters[i])) {
+			// Player ate a letter
+			LK.getSound('munch').play();
+			LK.setScore(LK.getScore() + letters[i].value);
+			scoreTxt.setText('Score: ' + LK.getScore());
+			letters[i].collected();
+			letters.splice(i, 1);
+		} else if (player.hasPowerup && player.hasPowerup === 'magnet') {
+			// Magnet powerup pulls letters closer
+			var dx = player.x - letters[i].x;
+			var dy = player.y - letters[i].y;
+			var dist = Math.sqrt(dx * dx + dy * dy);
+			if (dist < 400) {
+				letters[i].x += dx * 0.05;
+				letters[i].y += dy * 0.05;
+			}
+		}
+	}
+	// Check obstacle collisions
+	for (var j = obstacles.length - 1; j >= 0; j--) {
+		if (player.intersects(obstacles[j])) {
+			// Player hit an obstacle
+			LK.getSound('hit').play();
+			LK.effects.flashScreen(0xFF0000, 500);
+			// Game over
+			gameOver = true;
+			LK.showGameOver();
+			break;
+		}
+	}
+	// Check powerup collisions
+	for (var k = powerups.length - 1; k >= 0; k--) {
+		if (player.intersects(powerups[k])) {
+			// Player got a powerup
+			LK.getSound('powerup').play();
+			player.activatePowerup(powerups[k].type);
+			powerups[k].collected();
+			powerups.splice(k, 1);
+		}
+	}
+}
+// Event handlers
+game.down = function (x, y, obj) {
+	player.moveTo(x, y);
+};
+game.up = function (x, y, obj) {
+	// Optional: stop player when released
+};
+game.move = function (x, y, obj) {
+	if (player.isDragging) {
+		player.moveTo(x, y);
+	}
+};
+// Game update function
+game.update = function () {
+	if (gameOver) {
+		return;
+	}
+	// Update player
+	if (player) {
+		player.update();
+	}
+	// Update letters
+	for (var i = 0; i < letters.length; i++) {
+		if (letters[i] && letters[i].update) {
+			letters[i].update();
+		}
+	}
+	// Update obstacles
+	for (var j = 0; j < obstacles.length; j++) {
+		if (obstacles[j] && obstacles[j].update) {
+			obstacles[j].update();
+		}
+	}
+	// Update powerups
+	for (var k = 0; k < powerups.length; k++) {
+		if (powerups[k] && powerups[k].update) {
+			powerups[k].update();
+		}
+	}
+	// Check collisions
+	checkCollisions();
+};
+// Initialize the game when everything is loaded
+initGame();
\ No newline at end of file