===================================================================
--- original.js
+++ change.js
@@ -1,6 +1,544 @@
-/****
+/**** 
+* Plugins
+****/ 
+var tween = LK.import("@upit/tween.v1");
+var storage = LK.import("@upit/storage.v1");
+
+/**** 
+* Classes
+****/ 
+var Note = Container.expand(function () {
+	var self = Container.call(this);
+	self.type = 'normal'; // normal, perfect, good
+	self.lane = 0; // 0-3 for different lanes
+	self.speed = 10; // Base speed
+	self.active = true; // Whether note is still active
+	self.scored = false; // Whether note has been scored
+	self.noteGraphics = null;
+	self.init = function (noteType, laneNum, noteSpeed) {
+		self.type = noteType || 'normal';
+		self.lane = laneNum || 0;
+		self.speed = noteSpeed || 10;
+		// Create note graphic based on type
+		var assetId = 'note';
+		if (self.type === 'perfect') {
+			assetId = 'perfectNote';
+		} else if (self.type === 'good') {
+			assetId = 'goodNote';
+		}
+		self.noteGraphics = self.attachAsset(assetId, {
+			anchorX: 0.5,
+			anchorY: 0.5,
+			alpha: 0.9
+		});
+		return self;
+	};
+	self.update = function () {
+		if (!self.active) {
+			return;
+		}
+		// Move note down
+		self.y += self.speed;
+		// Check if note is out of bounds and hasn't been scored
+		if (self.y > 2732 + 100 && !self.scored) {
+			self.miss();
+		}
+	};
+	self.hit = function (accuracy) {
+		if (!self.active || self.scored) {
+			return;
+		}
+		self.scored = true;
+		self.active = false;
+		// Create hit effect
+		LK.effects.flashObject(self, 0xFFFFFF, 300);
+		if (accuracy === 'perfect') {
+			LK.getSound('perfectSound').play();
+			tween(self.noteGraphics, {
+				alpha: 0,
+				scaleX: 1.5,
+				scaleY: 1.5
+			}, {
+				duration: 300,
+				onFinish: function onFinish() {
+					self.destroy();
+				}
+			});
+		} else if (accuracy === 'good') {
+			LK.getSound('hitSound').play();
+			tween(self.noteGraphics, {
+				alpha: 0,
+				scaleX: 1.3,
+				scaleY: 1.3
+			}, {
+				duration: 300,
+				onFinish: function onFinish() {
+					self.destroy();
+				}
+			});
+		} else {
+			LK.getSound('hitSound').play();
+			tween(self.noteGraphics, {
+				alpha: 0
+			}, {
+				duration: 200,
+				onFinish: function onFinish() {
+					self.destroy();
+				}
+			});
+		}
+	};
+	self.miss = function () {
+		if (!self.active || self.scored) {
+			return;
+		}
+		self.scored = true;
+		self.active = false;
+		LK.getSound('missSound').play();
+		// Change to missed note appearance
+		if (self.noteGraphics) {
+			self.removeChild(self.noteGraphics);
+		}
+		self.noteGraphics = self.attachAsset('missedNote', {
+			anchorX: 0.5,
+			anchorY: 0.5,
+			alpha: 0.5
+		});
+		tween(self.noteGraphics, {
+			alpha: 0
+		}, {
+			duration: 200,
+			onFinish: function onFinish() {
+				self.destroy();
+			}
+		});
+	};
+	return self;
+});
+var ScoreDisplay = Container.expand(function () {
+	var self = Container.call(this);
+	self.scoreText = null;
+	self.comboText = null;
+	self.accuracyText = null;
+	self.feedbackText = null;
+	self.init = function () {
+		// Create score text
+		self.scoreText = new Text2('Score: 0', {
+			size: 80,
+			fill: 0xFFFFFF
+		});
+		self.scoreText.anchor.set(0.5, 0);
+		self.addChild(self.scoreText);
+		// Create combo text
+		self.comboText = new Text2('Combo: 0', {
+			size: 60,
+			fill: 0xFFFFFF
+		});
+		self.comboText.anchor.set(0.5, 0);
+		self.comboText.y = 90;
+		self.addChild(self.comboText);
+		// Create accuracy text
+		self.accuracyText = new Text2('Accuracy: 0%', {
+			size: 40,
+			fill: 0xDDDDDD
+		});
+		self.accuracyText.anchor.set(0.5, 0);
+		self.accuracyText.y = 160;
+		self.addChild(self.accuracyText);
+		// Create feedback text for "Perfect!", "Good!", "Miss!"
+		self.feedbackText = new Text2('', {
+			size: 90,
+			fill: 0xFFFFFF
+		});
+		self.feedbackText.anchor.set(0.5, 0.5);
+		self.feedbackText.y = 300;
+		self.addChild(self.feedbackText);
+		return self;
+	};
+	self.updateScore = function (score) {
+		self.scoreText.setText('Score: ' + score);
+	};
+	self.updateCombo = function (combo) {
+		self.comboText.setText('Combo: ' + combo);
+		// Scale effect on combo update
+		tween.stop(self.comboText, {
+			scaleX: true,
+			scaleY: true
+		});
+		self.comboText.scale.set(1.2, 1.2);
+		tween(self.comboText, {
+			scaleX: 1,
+			scaleY: 1
+		}, {
+			duration: 300,
+			easing: tween.elasticOut
+		});
+	};
+	self.updateAccuracy = function (accuracy) {
+		self.accuracyText.setText('Accuracy: ' + accuracy + '%');
+	};
+	self.showFeedback = function (type) {
+		// Clear any existing animations
+		tween.stop(self.feedbackText, {
+			alpha: true,
+			scaleX: true,
+			scaleY: true
+		});
+		var color = "#FFFFFF";
+		var text = "";
+		if (type === 'perfect') {
+			text = "Perfect!";
+			color = "#FF4500";
+		} else if (type === 'good') {
+			text = "Good!";
+			color = "#32CD32";
+		} else if (type === 'miss') {
+			text = "Miss!";
+			color = "#888888";
+		}
+		self.feedbackText.setText(text);
+		self.feedbackText.style.fill = color;
+		self.feedbackText.alpha = 1;
+		self.feedbackText.scale.set(1.3, 1.3);
+		tween(self.feedbackText, {
+			alpha: 0,
+			scaleX: 1,
+			scaleY: 1
+		}, {
+			duration: 600,
+			easing: tween.easeOut
+		});
+	};
+	return self;
+});
+var TargetZone = Container.expand(function () {
+	var self = Container.call(this);
+	self.lane = 0;
+	self.zoneGraphics = null;
+	self.active = false;
+	self.pulseTimer = 0;
+	self.init = function (laneNum) {
+		self.lane = laneNum || 0;
+		self.zoneGraphics = self.attachAsset('targetZone', {
+			anchorX: 0.5,
+			anchorY: 0.5,
+			alpha: 0.4
+		});
+		return self;
+	};
+	self.update = function () {
+		// Subtle pulsing effect when not active
+		if (!self.active) {
+			self.pulseTimer += 0.05;
+			self.zoneGraphics.alpha = 0.3 + Math.sin(self.pulseTimer) * 0.1;
+		}
+	};
+	self.activate = function () {
+		if (self.active) {
+			return;
+		}
+		self.active = true;
+		tween(self.zoneGraphics, {
+			alpha: 0.8,
+			scaleX: 1.1,
+			scaleY: 1.1
+		}, {
+			duration: 100,
+			onFinish: function onFinish() {
+				self.deactivate();
+			}
+		});
+	};
+	self.deactivate = function () {
+		self.active = false;
+		tween(self.zoneGraphics, {
+			alpha: 0.4,
+			scaleX: 1.0,
+			scaleY: 1.0
+		}, {
+			duration: 200
+		});
+	};
+	self.down = function (x, y, obj) {
+		self.activate();
+	};
+	return self;
+});
+
+/**** 
 * Initialize Game
-****/
+****/ 
 var game = new LK.Game({
-	backgroundColor: 0x000000
-});
\ No newline at end of file
+	backgroundColor: 0x111133
+});
+
+/**** 
+* Game Code
+****/ 
+// Game configuration
+var laneCount = 4;
+var laneWidth = 2048 / laneCount;
+var gameSpeed = 5; // Base speed multiplier
+var currentLevel = 1;
+var difficultyMultiplier = 1.0;
+var beatFrequency = 60; // Frames between beat patterns
+var beatVariance = 10; // Random variation in beat timing
+var nextBeatFrame = 20; // When to spawn the next beat
+// Game state
+var score = 0;
+var combo = 0;
+var maxCombo = 0;
+var totalNotes = 0;
+var hitNotes = 0;
+var perfectHits = 0;
+var activeNotes = [];
+var targetZones = [];
+var gameStarted = false;
+var gameOver = false;
+// UI elements
+var scoreDisplay;
+var startText;
+var backgroundShape;
+// Add background
+backgroundShape = game.addChild(LK.getAsset('background', {
+	anchorX: 0,
+	anchorY: 0
+}));
+// Create target zones
+for (var i = 0; i < laneCount; i++) {
+	var zone = new TargetZone().init(i);
+	zone.x = laneWidth * (i + 0.5);
+	zone.y = 2500; // Bottom of screen
+	targetZones.push(zone);
+	game.addChild(zone);
+}
+// Create and position score display
+scoreDisplay = new ScoreDisplay().init();
+scoreDisplay.x = 2048 / 2;
+scoreDisplay.y = 150;
+game.addChild(scoreDisplay);
+// Create start text
+startText = new Text2('Tap to Start', {
+	size: 120,
+	fill: 0xFFFFFF
+});
+startText.anchor.set(0.5, 0.5);
+startText.x = 2048 / 2;
+startText.y = 2732 / 2;
+game.addChild(startText);
+// Calculate accuracy as a percentage
+function calculateAccuracy() {
+	if (totalNotes === 0) {
+		return 100;
+	}
+	return Math.floor(hitNotes / totalNotes * 100);
+}
+// Spawn a new note
+function spawnNote() {
+	var laneNum = Math.floor(Math.random() * laneCount);
+	var noteType = 'normal';
+	// 20% chance for a "perfect" note, 30% chance for a "good" note
+	var rand = Math.random();
+	if (rand < 0.2) {
+		noteType = 'perfect';
+	} else if (rand < 0.5) {
+		noteType = 'good';
+	}
+	var noteSpeed = gameSpeed * difficultyMultiplier;
+	var note = new Note().init(noteType, laneNum, noteSpeed);
+	note.x = laneWidth * (laneNum + 0.5);
+	note.y = -50; // Start above the screen
+	activeNotes.push(note);
+	game.addChild(note);
+	totalNotes++;
+	return note;
+}
+// Generate beat pattern
+function generateBeatPattern() {
+	var patternLength = Math.min(4, 1 + Math.floor(currentLevel / 2));
+	for (var i = 0; i < patternLength; i++) {
+		// Stagger notes based on pattern position
+		LK.setTimeout(function () {
+			if (!gameOver && gameStarted) {
+				spawnNote();
+			}
+		}, i * (200 / difficultyMultiplier));
+	}
+}
+// Check if a note is in the hit zone
+function checkNoteHit(laneNum) {
+	var hitZone = targetZones[laneNum];
+	var hitY = hitZone.y;
+	var hitFound = false;
+	// Find notes in this lane
+	for (var i = 0; i < activeNotes.length; i++) {
+		var note = activeNotes[i];
+		if (note.lane === laneNum && note.active && !note.scored) {
+			// Calculate distance from perfect hit position
+			var distance = Math.abs(note.y - hitY);
+			// Different hit zones based on distance
+			if (distance < 30) {
+				// Perfect hit
+				score += 100 * (1 + combo / 10);
+				combo++;
+				hitNotes++;
+				perfectHits++;
+				note.hit('perfect');
+				scoreDisplay.showFeedback('perfect');
+				hitFound = true;
+				break;
+			} else if (distance < 60) {
+				// Good hit
+				score += 50 * (1 + combo / 20);
+				combo++;
+				hitNotes++;
+				note.hit('good');
+				scoreDisplay.showFeedback('good');
+				hitFound = true;
+				break;
+			} else if (distance < 120 && note.y < hitY) {
+				// Approaching, but not quite there - early hit
+				score += 10;
+				combo++;
+				hitNotes++;
+				note.hit('early');
+				scoreDisplay.showFeedback('good');
+				hitFound = true;
+				break;
+			}
+		}
+	}
+	// If we didn't hit any notes, it's a miss
+	if (!hitFound) {
+		combo = 0;
+		scoreDisplay.showFeedback('miss');
+	}
+	// Update score display
+	scoreDisplay.updateScore(Math.floor(score));
+	scoreDisplay.updateCombo(combo);
+	maxCombo = Math.max(maxCombo, combo);
+	// Update accuracy
+	var accuracy = calculateAccuracy();
+	scoreDisplay.updateAccuracy(accuracy);
+	return hitFound;
+}
+// Handle tap on a lane
+function handleLaneTap(laneNum) {
+	if (!gameStarted || gameOver) {
+		return;
+	}
+	targetZones[laneNum].activate();
+	return checkNoteHit(laneNum);
+}
+// Start the game
+function startGame() {
+	if (gameStarted) {
+		return;
+	}
+	gameStarted = true;
+	game.removeChild(startText);
+	// Reset game state
+	score = 0;
+	combo = 0;
+	maxCombo = 0;
+	totalNotes = 0;
+	hitNotes = 0;
+	perfectHits = 0;
+	currentLevel = 1;
+	difficultyMultiplier = 1.0;
+	gameOver = false;
+	// Update UI
+	scoreDisplay.updateScore(score);
+	scoreDisplay.updateCombo(combo);
+	scoreDisplay.updateAccuracy(100);
+	// Start music
+	LK.playMusic('gameMusic', {
+		fade: {
+			start: 0,
+			end: 1,
+			duration: 1000
+		}
+	});
+	// Set the first beat to spawn soon
+	nextBeatFrame = 60;
+}
+// Check if game should end (based on time or score)
+function checkGameOver() {
+	// For demo purposes, end game after reaching level 10
+	if (currentLevel >= 10 && score >= 10000) {
+		endGame(true); // Win
+	}
+	// Player loses if accuracy drops too low
+	if (totalNotes > 20 && calculateAccuracy() < 40) {
+		endGame(false); // Lose
+	}
+}
+// End the game
+function endGame(win) {
+	gameOver = true;
+	// Fade out music
+	LK.playMusic('gameMusic', {
+		fade: {
+			start: 1,
+			end: 0,
+			duration: 800
+		}
+	});
+	// Show game over or win screen based on performance
+	if (win) {
+		LK.showYouWin();
+	} else {
+		LK.showGameOver();
+	}
+}
+// Handle lane tap detection - we'll divide the screen into lanes
+function getLaneFromPosition(x) {
+	return Math.floor(x / laneWidth);
+}
+// Handle touch events
+game.down = function (x, y, obj) {
+	if (!gameStarted) {
+		startGame();
+	} else {
+		var lane = getLaneFromPosition(x);
+		if (lane >= 0 && lane < laneCount) {
+			handleLaneTap(lane);
+		}
+	}
+};
+game.update = function () {
+	if (!gameStarted) {
+		return;
+	}
+	// Update all active notes
+	for (var i = activeNotes.length - 1; i >= 0; i--) {
+		var note = activeNotes[i];
+		// Remove notes that have been scored and faded out
+		if (!note.active && note.scored) {
+			activeNotes.splice(i, 1);
+		}
+	}
+	// Update target zones
+	for (var j = 0; j < targetZones.length; j++) {
+		targetZones[j].update();
+	}
+	// Generate new beat patterns at intervals
+	if (gameStarted && !gameOver) {
+		if (LK.ticks >= nextBeatFrame) {
+			generateBeatPattern();
+			// Calculate next beat timing with some variance
+			var interval = beatFrequency - currentLevel * 5;
+			interval = Math.max(interval, 30); // Don't go too fast
+			var variance = Math.floor(Math.random() * beatVariance) - beatVariance / 2;
+			nextBeatFrame = LK.ticks + interval + variance;
+			// Increase difficulty over time
+			if (LK.ticks % 600 === 0) {
+				// Every 10 seconds
+				currentLevel++;
+				difficultyMultiplier = 1.0 + currentLevel * 0.1;
+			}
+		}
+	}
+	// Check for game over conditions
+	checkGameOver();
+};
\ No newline at end of file