===================================================================
--- original.js
+++ change.js
@@ -1,6 +1,438 @@
-/****
+/**** 
+* Plugins
+****/ 
+var tween = LK.import("@upit/tween.v1");
+var storage = LK.import("@upit/storage.v1", {
+	highScore: 0,
+	level: 1
+});
+
+/**** 
+* Classes
+****/ 
+var Balloon = Container.expand(function (type, speed, value) {
+	var self = Container.call(this);
+	self.type = type || 'red';
+	self.speed = speed || 3;
+	self.value = value || 10;
+	self.popped = false;
+	// Determine balloon color and behavior based on type
+	var balloonColor;
+	if (self.type === 'red') {
+		balloonColor = 'balloon_red';
+	} else if (self.type === 'green') {
+		balloonColor = 'balloon_green';
+	} else if (self.type === 'blue') {
+		balloonColor = 'balloon_blue';
+	} else if (self.type === 'yellow') {
+		balloonColor = 'balloon_yellow';
+	} else if (self.type === 'purple') {
+		balloonColor = 'balloon_purple';
+	} else if (self.type === 'slow') {
+		balloonColor = 'powerup_slow';
+		self.isPowerup = true;
+		self.powerupType = 'slow';
+	} else if (self.type === 'double') {
+		balloonColor = 'powerup_double';
+		self.isPowerup = true;
+		self.powerupType = 'double';
+	} else if (self.type === 'freeze') {
+		balloonColor = 'powerup_freeze';
+		self.isPowerup = true;
+		self.powerupType = 'freeze';
+	}
+	// Create balloon body
+	self.body = self.attachAsset(balloonColor, {
+		anchorX: 0.5,
+		anchorY: 0.5
+	});
+	// Only add strings to regular balloons, not powerups
+	if (!self.isPowerup) {
+		// Add balloon string
+		self.string = self.attachAsset('balloon_string', {
+			anchorX: 0.5,
+			anchorY: 0
+		});
+		self.string.y = self.body.height / 2;
+	}
+	// Interactive elements need to be flagged as such
+	self.body.interactive = true;
+	// Event handler for popping balloon
+	self.down = function (x, y, obj) {
+		if (!self.popped && !gameOver && !gamePaused) {
+			self.pop();
+		}
+	};
+	// Pop the balloon
+	self.pop = function () {
+		if (self.popped) {
+			return;
+		}
+		self.popped = true;
+		// Check if this is a good or bad balloon
+		if (self.type === 'red' || self.type === 'green' || self.type === 'blue') {
+			// Good balloon - add points
+			LK.setScore(LK.getScore() + self.value * pointMultiplier);
+			LK.getSound('pop').play();
+			// Flash balloon white before removing
+			LK.effects.flashObject(self, 0xffffff, 300);
+		} else if (self.type === 'yellow' || self.type === 'purple') {
+			// Bad balloon - subtract points
+			LK.setScore(Math.max(0, LK.getScore() - self.value));
+			LK.getSound('bad_pop').play();
+			// Flash balloon red before removing
+			LK.effects.flashObject(self, 0xff0000, 300);
+		} else if (self.isPowerup) {
+			// Powerup balloon
+			LK.getSound('powerup').play();
+			// Flash balloon white
+			LK.effects.flashObject(self, 0xffffff, 300);
+			// Apply powerup effect
+			if (self.powerupType === 'slow') {
+				gameSpeed = 0.5;
+				// Reset game speed after 5 seconds
+				LK.setTimeout(function () {
+					gameSpeed = 1;
+				}, 5000);
+			} else if (self.powerupType === 'double') {
+				pointMultiplier = 2;
+				// Reset point multiplier after 5 seconds
+				LK.setTimeout(function () {
+					pointMultiplier = 1;
+				}, 5000);
+			} else if (self.powerupType === 'freeze') {
+				freezeMode = true;
+				// Reset freeze mode after 3 seconds
+				LK.setTimeout(function () {
+					freezeMode = false;
+				}, 3000);
+			}
+		}
+		// Update score display
+		updateScoreDisplay();
+		// Remove balloon after short delay to allow for flash effect
+		LK.setTimeout(function () {
+			self.visible = false;
+			// Find balloon in array and remove it
+			var balloonIndex = balloons.indexOf(self);
+			if (balloonIndex !== -1) {
+				balloons.splice(balloonIndex, 1);
+				self.destroy();
+			}
+		}, 300);
+	};
+	self.update = function () {
+		if (self.popped) {
+			return;
+		}
+		// Don't move if game is in freeze mode
+		if (freezeMode) {
+			return;
+		}
+		// Move balloon upward
+		self.y -= self.speed * gameSpeed;
+		// Remove balloon if it goes off the top of the screen
+		if (self.y < -200) {
+			var balloonIndex = balloons.indexOf(self);
+			if (balloonIndex !== -1) {
+				balloons.splice(balloonIndex, 1);
+				self.destroy();
+				// Penalty for missing good balloons
+				if (self.type === 'red' || self.type === 'green' || self.type === 'blue') {
+					LK.setScore(Math.max(0, LK.getScore() - Math.floor(self.value / 2)));
+					updateScoreDisplay();
+				}
+			}
+		}
+	};
+	return self;
+});
+var PowerupIndicator = Container.expand(function (type) {
+	var self = Container.call(this);
+	self.type = type;
+	// Create indicator shape
+	var indicatorAsset;
+	if (self.type === 'slow') {
+		indicatorAsset = 'powerup_slow';
+	} else if (self.type === 'double') {
+		indicatorAsset = 'powerup_double';
+	} else if (self.type === 'freeze') {
+		indicatorAsset = 'powerup_freeze';
+	}
+	self.indicator = self.attachAsset(indicatorAsset, {
+		anchorX: 0.5,
+		anchorY: 0.5,
+		scaleX: 0.5,
+		scaleY: 0.5
+	});
+	self.timeRemaining = 0;
+	self.active = false;
+	self.activate = function (duration) {
+		self.timeRemaining = duration;
+		self.active = true;
+		self.alpha = 1;
+	};
+	self.update = function () {
+		if (self.active) {
+			self.timeRemaining -= 16.67; // Approximate ms per frame at 60fps
+			if (self.timeRemaining <= 0) {
+				self.active = false;
+				self.alpha = 0.3;
+			}
+		}
+	};
+	// Initial state is inactive
+	self.alpha = 0.3;
+	return self;
+});
+
+/**** 
 * Initialize Game
-****/
+****/ 
 var game = new LK.Game({
-	backgroundColor: 0x000000
-});
\ No newline at end of file
+	backgroundColor: 0x87CEEB
+});
+
+/**** 
+* Game Code
+****/ 
+// Game state variables
+var balloons = [];
+var spawnInterval;
+var levelTimers = [];
+var currentLevel = storage.level || 1;
+var gameOver = false;
+var gamePaused = false;
+var gameSpeed = 1;
+var pointMultiplier = 1;
+var freezeMode = false;
+var lastSpawnTime = 0;
+var spawnDelay = 1000; // starting spawn delay
+// UI elements
+var scoreTxt;
+var levelTxt;
+var highScoreTxt;
+var powerupIndicators = {};
+// Initialize game elements
+function initGame() {
+	// Clear any existing balloons
+	while (balloons.length > 0) {
+		balloons[0].destroy();
+		balloons.splice(0, 1);
+	}
+	// Clear any existing timers
+	if (spawnInterval) {
+		LK.clearInterval(spawnInterval);
+	}
+	levelTimers.forEach(function (timer) {
+		LK.clearTimeout(timer);
+	});
+	levelTimers = [];
+	// Reset game state
+	gameOver = false;
+	gamePaused = false;
+	gameSpeed = 1;
+	pointMultiplier = 1;
+	freezeMode = false;
+	// Setup UI
+	setupUI();
+	// Start balloon spawning
+	spawnInterval = LK.setInterval(spawnBalloon, spawnDelay);
+	// Play background music
+	LK.playMusic('bgmusic', {
+		fade: {
+			start: 0,
+			end: 0.5,
+			duration: 1000
+		}
+	});
+	// Set level based difficulty
+	setupLevelDifficulty();
+}
+// Create UI elements
+function setupUI() {
+	// Score display
+	scoreTxt = new Text2('Score: 0', {
+		size: 70,
+		fill: 0xFFFFFF
+	});
+	scoreTxt.anchor.set(0.5, 0);
+	LK.gui.top.addChild(scoreTxt);
+	scoreTxt.y = 20;
+	// Level display
+	levelTxt = new Text2('Level: ' + currentLevel, {
+		size: 50,
+		fill: 0xFFFFFF
+	});
+	levelTxt.anchor.set(0, 0);
+	LK.gui.topRight.addChild(levelTxt);
+	levelTxt.x = -180;
+	levelTxt.y = 20;
+	// High score display
+	highScoreTxt = new Text2('Best: ' + storage.highScore, {
+		size: 40,
+		fill: 0xFFFFFF
+	});
+	highScoreTxt.anchor.set(0, 0);
+	LK.gui.topRight.addChild(highScoreTxt);
+	highScoreTxt.x = -180;
+	highScoreTxt.y = 80;
+	// Powerup indicators
+	setupPowerupIndicators();
+	// Update displays
+	updateScoreDisplay();
+}
+// Setup powerup indicators
+function setupPowerupIndicators() {
+	// Create indicators for each powerup type
+	var types = ['slow', 'double', 'freeze'];
+	var startX = 130;
+	types.forEach(function (type, index) {
+		var indicator = new PowerupIndicator(type);
+		powerupIndicators[type] = indicator;
+		LK.gui.bottomLeft.addChild(indicator);
+		indicator.x = startX + index * 120;
+		indicator.y = -100;
+	});
+}
+// Update score display
+function updateScoreDisplay() {
+	scoreTxt.setText('Score: ' + LK.getScore());
+	// Update high score if needed
+	if (LK.getScore() > storage.highScore) {
+		storage.highScore = LK.getScore();
+		highScoreTxt.setText('Best: ' + storage.highScore);
+	}
+}
+// Set up difficulty based on current level
+function setupLevelDifficulty() {
+	// Adjust spawn delay based on level
+	spawnDelay = Math.max(300, 1000 - currentLevel * 100);
+	// Clear and set new spawn interval
+	if (spawnInterval) {
+		LK.clearInterval(spawnInterval);
+	}
+	spawnInterval = LK.setInterval(spawnBalloon, spawnDelay);
+	// Update level display
+	levelTxt.setText('Level: ' + currentLevel);
+	// Schedule level up if not at max level
+	if (currentLevel < 5) {
+		var levelTimer = LK.setTimeout(function () {
+			levelUp();
+		}, 30000); // Level up every 30 seconds
+		levelTimers.push(levelTimer);
+	}
+}
+// Level up function
+function levelUp() {
+	currentLevel++;
+	storage.level = currentLevel;
+	// Display level up message
+	var levelUpText = new Text2('LEVEL ' + currentLevel + '!', {
+		size: 120,
+		fill: 0xFFFFFF
+	});
+	levelUpText.anchor.set(0.5, 0.5);
+	game.addChild(levelUpText);
+	levelUpText.x = 2048 / 2;
+	levelUpText.y = 2732 / 2;
+	// Flash the screen
+	LK.effects.flashScreen(0xffff00, 1000);
+	// Remove level up text after a delay
+	LK.setTimeout(function () {
+		levelUpText.destroy();
+	}, 2000);
+	// Update difficulty
+	setupLevelDifficulty();
+}
+// Spawn a new balloon
+function spawnBalloon() {
+	if (gameOver || gamePaused) {
+		return;
+	}
+	// Determine balloon type based on level and randomness
+	var balloonType;
+	var balloonValue;
+	var balloonSpeed;
+	// Random value between 0 and 1
+	var rand = Math.random();
+	// Increase chance of power-ups and bad balloons as level increases
+	var powerupChance = 0.05 + currentLevel * 0.02; // 5% base plus 2% per level
+	var badBalloonChance = 0.1 + currentLevel * 0.05; // 10% base plus 5% per level
+	if (rand < powerupChance) {
+		// Spawn a power-up balloon
+		var powerupRand = Math.random();
+		if (powerupRand < 0.33) {
+			balloonType = 'slow';
+		} else if (powerupRand < 0.66) {
+			balloonType = 'double';
+		} else {
+			balloonType = 'freeze';
+		}
+		balloonValue = 0;
+		balloonSpeed = 2 + currentLevel * 0.5;
+	} else if (rand < powerupChance + badBalloonChance) {
+		// Spawn a bad balloon
+		balloonType = Math.random() < 0.5 ? 'yellow' : 'purple';
+		balloonValue = 10 + currentLevel * 5;
+		balloonSpeed = 3 + currentLevel * 0.7;
+	} else {
+		// Spawn a good balloon
+		var goodRand = Math.random();
+		if (goodRand < 0.33) {
+			balloonType = 'red';
+		} else if (goodRand < 0.66) {
+			balloonType = 'green';
+		} else {
+			balloonType = 'blue';
+		}
+		balloonValue = 10 + currentLevel * 3;
+		balloonSpeed = 2 + currentLevel * 0.6;
+	}
+	// Create the balloon
+	var balloon = new Balloon(balloonType, balloonSpeed, balloonValue);
+	// Position balloon randomly along the bottom of the screen
+	balloon.x = Math.random() * (2048 - 200) + 100; // Keep away from edges
+	balloon.y = 2732 + 100; // Start below screen
+	// Add to game and tracking array
+	game.addChild(balloon);
+	balloons.push(balloon);
+}
+// Check for game over conditions
+function checkGameOver() {
+	// In this simple version, the game doesn't end until the player chooses to end it
+	// You could add lives or a timer if desired
+}
+// Update game state
+game.update = function () {
+	// Update all balloons
+	for (var i = balloons.length - 1; i >= 0; i--) {
+		if (balloons[i]) {
+			balloons[i].update();
+		}
+	}
+	// Update powerup indicators
+	for (var type in powerupIndicators) {
+		if (powerupIndicators[type]) {
+			powerupIndicators[type].update();
+		}
+	}
+	// Update powerup indicators based on current state
+	if (gameSpeed < 1) {
+		powerupIndicators['slow'].activate(5000);
+	}
+	if (pointMultiplier > 1) {
+		powerupIndicators['double'].activate(5000);
+	}
+	if (freezeMode) {
+		powerupIndicators['freeze'].activate(3000);
+	}
+	// Check for game over conditions
+	checkGameOver();
+};
+// Game press event handler
+game.down = function (x, y, obj) {
+	// This is handled by individual balloon objects
+};
+// Initialize game on startup
+initGame();
\ No newline at end of file