/**** 
* Plugins
****/ 
var tween = LK.import("@upit/tween.v1");

/**** 
* Classes
****/ 
var Column = Container.expand(function () {
	var self = Container.call(this);
	var columnGraphics = self.attachAsset('column', {
		anchorX: 0.5,
		anchorY: 0,
		alpha: 0.3
	});
	var scoreZone = self.attachAsset('scoreZone', {
		anchorX: 0.5,
		anchorY: 0.5,
		y: 2732 - 200,
		alpha: 0.4
	});
	self.scoreZoneY = 2732 - 200;
	return self;
});
var Tile = Container.expand(function () {
	var self = Container.call(this);
	var tileGraphics = self.attachAsset('tile', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.speed = 6;
	self.columnIndex = 0;
	self.scored = false;
	self.missed = false;
	self.update = function () {
		self.y += self.speed;
	};
	return self;
});

/**** 
* Initialize Game
****/ 
var game = new LK.Game({
	backgroundColor: 0x1a1a2e
});

/**** 
* Game Code
****/ 
var columns = [];
var tiles = [];
var score = 0;
var gameStarted = false;
var musicDuration = 22000; // 22 seconds
var gameStartTime = 0;
var perfectZone = 50;
var goodZone = 100;
var pianoTones = ['noteA3', 'noteC4', 'noteE4', 'noteG4'];
// Create UI
var scoreTxt = new Text2('Score: 0', {
	size: 120,
	fill: 0xFFFFFF
});
scoreTxt.anchor.set(0.5, 0);
LK.gui.top.addChild(scoreTxt);
// Create columns
var columnWidth = 2048 / 4;
for (var i = 0; i < 4; i++) {
	var column = new Column();
	column.x = i * columnWidth + columnWidth / 2;
	column.y = 0;
	columns.push(column);
	game.addChild(column);
}
// Multiple predefined melody patterns for variety
var melodyPatterns = [[1, 1, 2, 2, 3, 3, 2, 2, 1],
// Pattern A: C4, C4, E4, E4, G4, G4, E4, E4, C4
[3, 2, 1, 1, 0, 0, 1, 2],
// Pattern B: G4, E4, C4, C4, A3, A3, C4, E4
[0, 2, 1, 3, 0, 2, 1, 3],
// Pattern C: A3, E4, C4, G4, A3, E4, C4, G4
[3, 1, 3, 1, 2, 2, 0, 0] // Pattern D: G4, C4, G4, C4, E4, E4, A3, A3
];
var currentPatternIndex = 0;
var melodyPattern = melodyPatterns[currentPatternIndex];
var spawnPattern = [];
var beatInterval = 500; // 500ms per beat for steady rhythm
var patternRepeatDuration = melodyPattern.length * beatInterval; // 9 beats = 4500ms per pattern
// Generate spawn pattern by repeating the melody pattern throughout the game duration
var currentTime = 500; // Start after 500ms
var patternPosition = 0;
while (currentTime < musicDuration) {
	spawnPattern.push({
		time: currentTime,
		columns: [melodyPattern[patternPosition]]
	});
	currentTime += beatInterval;
	patternPosition = (patternPosition + 1) % melodyPattern.length;
}
var patternIndex = 0;
function spawnTile(columnIndex) {
	var tile = new Tile();
	tile.columnIndex = columnIndex;
	tile.x = columns[columnIndex].x;
	tile.y = -60;
	tiles.push(tile);
	game.addChild(tile);
}
function calculateScore(distance) {
	if (distance <= perfectZone) {
		return 100;
	} else if (distance <= goodZone) {
		return 50;
	}
	return 0;
}
function updateScore(points) {
	score += points;
	scoreTxt.setText('Score: ' + score);
}
game.down = function (x, y, obj) {
	if (!gameStarted) {
		gameStarted = true;
		gameStartTime = LK.ticks * (1000 / 60);
		LK.playMusic('gamesound3_backing', {
			loop: true
		});
		return;
	}
	// Determine which column was tapped
	var columnIndex = Math.floor(x / columnWidth);
	if (columnIndex < 0) columnIndex = 0;
	if (columnIndex > 3) columnIndex = 3;
	var hitTile = null;
	var bestDistance = Infinity;
	// Find the closest tile in the tapped column within scoring range
	for (var i = 0; i < tiles.length; i++) {
		var tile = tiles[i];
		if (tile.columnIndex === columnIndex && !tile.scored && !tile.missed) {
			var scoreZoneY = columns[columnIndex].scoreZoneY;
			var distance = Math.abs(tile.y - scoreZoneY);
			if (distance <= goodZone && distance < bestDistance) {
				bestDistance = distance;
				hitTile = tile;
			}
		}
	}
	if (hitTile) {
		hitTile.scored = true;
		var points = calculateScore(bestDistance);
		updateScore(points);
		// Visual feedback
		if (points === 100) {
			LK.effects.flashObject(hitTile, 0x00ff00, 200);
		} else if (points === 50) {
			LK.effects.flashObject(hitTile, 0xffff00, 200);
		}
		LK.getSound(pianoTones[columnIndex]).play();
		// Remove tile
		hitTile.destroy();
		for (var j = tiles.length - 1; j >= 0; j--) {
			if (tiles[j] === hitTile) {
				tiles.splice(j, 1);
				break;
			}
		}
	}
};
game.update = function () {
	if (!gameStarted) {
		return;
	}
	var currentTime = LK.ticks * (1000 / 60) - gameStartTime;
	// Spawn tiles according to endless repeating pattern with pattern cycling
	var patternTime = currentTime % patternRepeatDuration; // Loop the pattern timing
	var shouldSpawn = false;
	// Check if we need to switch to the next pattern
	var patternCycleTime = Math.floor(currentTime / patternRepeatDuration);
	var newPatternIndex = patternCycleTime % melodyPatterns.length;
	if (newPatternIndex !== currentPatternIndex) {
		currentPatternIndex = newPatternIndex;
		melodyPattern = melodyPatterns[currentPatternIndex];
	}
	for (var p = 0; p < melodyPattern.length; p++) {
		var spawnTime = p * beatInterval + 500; // Add initial 500ms offset
		if (Math.abs(patternTime - spawnTime) < 16) {
			// 16ms tolerance for 60fps
			spawnTile(melodyPattern[p]);
			shouldSpawn = true;
			break;
		}
	}
	// Update tiles and check for misses
	for (var i = tiles.length - 1; i >= 0; i--) {
		var tile = tiles[i];
		// Check if tile passed the scoring zone without being hit
		if (!tile.scored && !tile.missed && tile.y > columns[tile.columnIndex].scoreZoneY + goodZone) {
			tile.missed = true;
			LK.effects.flashObject(tile, 0xff0000, 300);
			LK.getSound('miss').play();
		}
		// Remove tiles that are off screen
		if (tile.y > 2732 + 100) {
			tile.destroy();
			tiles.splice(i, 1);
		}
	}
};

===================================================================
--- original.js
+++ change.js
@@ -72,10 +72,19 @@
 	column.y = 0;
 	columns.push(column);
 	game.addChild(column);
 }
-// Predefined melody pattern: [2, 2, 3, 3, 4, 4, 3, 3, 2] (using columns 1-4 instead of 0-3)
-var melodyPattern = [1, 1, 2, 2, 3, 3, 2, 2, 1]; // C4, C4, E4, E4, G4, G4, E4, E4, C4
+// Multiple predefined melody patterns for variety
+var melodyPatterns = [[1, 1, 2, 2, 3, 3, 2, 2, 1],
+// Pattern A: C4, C4, E4, E4, G4, G4, E4, E4, C4
+[3, 2, 1, 1, 0, 0, 1, 2],
+// Pattern B: G4, E4, C4, C4, A3, A3, C4, E4
+[0, 2, 1, 3, 0, 2, 1, 3],
+// Pattern C: A3, E4, C4, G4, A3, E4, C4, G4
+[3, 1, 3, 1, 2, 2, 0, 0] // Pattern D: G4, C4, G4, C4, E4, E4, A3, A3
+];
+var currentPatternIndex = 0;
+var melodyPattern = melodyPatterns[currentPatternIndex];
 var spawnPattern = [];
 var beatInterval = 500; // 500ms per beat for steady rhythm
 var patternRepeatDuration = melodyPattern.length * beatInterval; // 9 beats = 4500ms per pattern
 // Generate spawn pattern by repeating the melody pattern throughout the game duration
@@ -162,11 +171,18 @@
 	if (!gameStarted) {
 		return;
 	}
 	var currentTime = LK.ticks * (1000 / 60) - gameStartTime;
-	// Spawn tiles according to endless repeating pattern
+	// Spawn tiles according to endless repeating pattern with pattern cycling
 	var patternTime = currentTime % patternRepeatDuration; // Loop the pattern timing
 	var shouldSpawn = false;
+	// Check if we need to switch to the next pattern
+	var patternCycleTime = Math.floor(currentTime / patternRepeatDuration);
+	var newPatternIndex = patternCycleTime % melodyPatterns.length;
+	if (newPatternIndex !== currentPatternIndex) {
+		currentPatternIndex = newPatternIndex;
+		melodyPattern = melodyPatterns[currentPatternIndex];
+	}
 	for (var p = 0; p < melodyPattern.length; p++) {
 		var spawnTime = p * beatInterval + 500; // Add initial 500ms offset
 		if (Math.abs(patternTime - spawnTime) < 16) {
 			// 16ms tolerance for 60fps