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

/**** 
* Classes
****/ 
var Card = Container.expand(function (isWinning) {
	var self = Container.call(this);
	self.isWinning = isWinning || false;
	self.isFlipped = false;
	self.isClickable = true;
	// Create card back (visible initially)
	var cardBack = self.attachAsset('cardBack', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Create card front (hidden initially)
	var cardFront = self.attachAsset(self.isWinning ? 'cardFront' : 'wrongCard', {
		anchorX: 0.5,
		anchorY: 0.5,
		alpha: 0
	});
	self.flip = function () {
		if (!self.isClickable || self.isFlipped) return;
		self.isFlipped = true;
		self.isClickable = false;
		// Flip animation
		tween(cardBack, {
			scaleX: 0
		}, {
			duration: 150,
			onFinish: function onFinish() {
				cardBack.alpha = 0;
				cardFront.alpha = 1;
				cardFront.scaleX = 0;
				tween(cardFront, {
					scaleX: 1
				}, {
					duration: 150
				});
			}
		});
		// Trigger game logic
		if (self.isWinning) {
			game.onCorrectCard();
		} else {
			game.onWrongCard();
		}
	};
	self.down = function (x, y, obj) {
		self.flip();
	};
	return self;
});

/**** 
* Initialize Game
****/ 
// Assets will be initialized automatically when needed
// Classes will be defined here
var game = new LK.Game({
	backgroundColor: 0x2c3e50
});

/**** 
* Game Code
****/ 
// Add background
var background = game.attachAsset('background', {
	anchorX: 0.5,
	anchorY: 0.5
});
background.x = 1024;
background.y = 1366;
// Game variables
var currentLevel = 1;
var maxLevel = 9;
var cards = [];
var gameState = 'playing'; // 'playing', 'won', 'lost'
// UI elements
var levelText = new Text2('Level: 1', {
	size: 80,
	fill: 0xFFFFFF
});
levelText.anchor.set(0.5, 0);
LK.gui.top.addChild(levelText);
var instructionText = new Text2('Find the green card!', {
	size: 60,
	fill: 0xFFFFFF
});
instructionText.anchor.set(0.5, 0);
instructionText.y = 100;
LK.gui.top.addChild(instructionText);
function getCardsForLevel(level) {
	if (level <= 3) return 3;
	if (level <= 6) return 6;
	return 9;
}
function createLevel() {
	// Clear existing cards
	for (var i = 0; i < cards.length; i++) {
		cards[i].destroy();
	}
	cards = [];
	var numCards = getCardsForLevel(currentLevel);
	var winningIndex = Math.floor(Math.random() * numCards);
	// Calculate card positions
	var cardSpacing = 450;
	var cardsPerRow = numCards <= 3 ? 3 : 3;
	var rows = Math.ceil(numCards / cardsPerRow);
	var startX = 1024 - (cardsPerRow - 1) * cardSpacing / 2;
	var startY = 1366 - (rows - 1) * 450 / 2;
	// Create cards
	for (var i = 0; i < numCards; i++) {
		var isWinning = i === winningIndex;
		var card = new Card(isWinning);
		var row = Math.floor(i / cardsPerRow);
		var col = i % cardsPerRow;
		card.x = startX + col * cardSpacing;
		card.y = startY + row * 350;
		cards.push(card);
		game.addChild(card);
	}
	// Update UI
	levelText.setText('Level: ' + currentLevel);
	gameState = 'playing';
	instructionText.setText('Remember this card...');
}
game.onCorrectCard = function () {
	gameState = 'won';
	// Disable all cards
	for (var i = 0; i < cards.length; i++) {
		cards[i].isClickable = false;
	}
	if (currentLevel >= maxLevel) {
		// Game complete
		instructionText.setText('Congratulations! You won!');
		LK.setTimeout(function () {
			LK.showYouWin();
		}, 1500);
	} else {
		// Next level
		instructionText.setText('Correct! Next level...');
		LK.setTimeout(function () {
			currentLevel++;
			createLevel();
			// Show winning card then shuffle for next level
			LK.setTimeout(function () {
				showWinningCard();
			}, 500);
		}, 1500);
	}
};
game.onWrongCard = function () {
	gameState = 'lost';
	// Disable all cards
	for (var i = 0; i < cards.length; i++) {
		cards[i].isClickable = false;
	}
	instructionText.setText('Wrong choice! Game Over');
	LK.setTimeout(function () {
		LK.showGameOver();
	}, 1500);
};
function showWinningCard() {
	// Find the winning card
	var winningCard = null;
	for (var i = 0; i < cards.length; i++) {
		if (cards[i].isWinning) {
			winningCard = cards[i];
			break;
		}
	}
	if (winningCard) {
		// Disable all cards during preview
		for (var i = 0; i < cards.length; i++) {
			cards[i].isClickable = false;
		}
		// Show the winning card briefly
		var cardBack = winningCard.children[0]; // cardBack asset
		var cardFront = winningCard.children[1]; // cardFront asset
		// Flip to show winning card
		tween(cardBack, {
			scaleX: 0
		}, {
			duration: 150,
			onFinish: function onFinish() {
				cardBack.alpha = 0;
				cardFront.alpha = 1;
				cardFront.scaleX = 0;
				tween(cardFront, {
					scaleX: 1
				}, {
					duration: 150,
					onFinish: function onFinish() {
						// Wait 2 seconds then flip back and shuffle
						LK.setTimeout(function () {
							tween(cardFront, {
								scaleX: 0
							}, {
								duration: 150,
								onFinish: function onFinish() {
									cardFront.alpha = 0;
									cardBack.alpha = 1;
									cardBack.scaleX = 0;
									tween(cardBack, {
										scaleX: 1
									}, {
										duration: 150,
										onFinish: function onFinish() {
											shuffleCards();
										}
									});
								}
							});
						}, 2000);
					}
				});
			}
		});
	}
}
function shuffleCards() {
	// Create shuffle animation by moving cards around
	var positions = [];
	for (var i = 0; i < cards.length; i++) {
		positions.push({
			x: cards[i].x,
			y: cards[i].y
		});
	}
	// Shuffle positions array multiple times for more randomness
	for (var shuffle = 0; shuffle < 5; shuffle++) {
		for (var i = positions.length - 1; i > 0; i--) {
			var j = Math.floor(Math.random() * (i + 1));
			var temp = positions[i];
			positions[i] = positions[j];
			positions[j] = temp;
		}
	}
	// Create multiple shuffle positions for more complex movement
	var shufflePositions = [];
	for (var phase = 0; phase < 4; phase++) {
		var phasePositions = [];
		for (var i = 0; i < cards.length; i++) {
			phasePositions.push({
				x: 300 + Math.random() * 1448,
				y: 800 + Math.random() * 800,
				rotation: -Math.PI / 3 + Math.random() * 2 * Math.PI / 3,
				scaleX: 0.8 + Math.random() * 0.3,
				scaleY: 0.8 + Math.random() * 0.3
			});
		}
		shufflePositions.push(phasePositions);
	}
	// Execute multiple shuffle phases
	var currentPhase = 0;
	var totalPhases = 4;
	function executeShufflePhase() {
		if (currentPhase >= totalPhases) {
			// Final phase: move cards to final positions
			var finalCompleted = 0;
			for (var k = 0; k < cards.length; k++) {
				tween(cards[k], {
					x: positions[k].x,
					y: positions[k].y,
					rotation: 0,
					scaleX: 1,
					scaleY: 1
				}, {
					duration: 1200,
					easing: tween.easeInOut,
					onFinish: function onFinish() {
						finalCompleted++;
						if (finalCompleted === cards.length) {
							// Re-enable cards after shuffle
							for (var l = 0; l < cards.length; l++) {
								cards[l].isClickable = true;
							}
							instructionText.setText('Find the green card!');
						}
					}
				});
			}
			return;
		}
		// Execute current phase
		var phaseCompleted = 0;
		var currentPositions = shufflePositions[currentPhase];
		for (var i = 0; i < cards.length; i++) {
			tween(cards[i], {
				x: currentPositions[i].x,
				y: currentPositions[i].y,
				rotation: currentPositions[i].rotation,
				scaleX: currentPositions[i].scaleX,
				scaleY: currentPositions[i].scaleY
			}, {
				duration: 500 + Math.random() * 400,
				easing: tween.easeInOut,
				onFinish: function onFinish() {
					phaseCompleted++;
					if (phaseCompleted === cards.length) {
						currentPhase++;
						// Small delay between phases
						LK.setTimeout(executeShufflePhase, 200);
					}
				}
			});
		}
	}
	// Start shuffling
	executeShufflePhase();
}
// Play background music
LK.playMusic('bgMusic');
// Initialize first level
createLevel();
// Show winning card then shuffle
LK.setTimeout(function () {
	showWinningCard();
}, 500);

===================================================================
--- original.js
+++ change.js
@@ -231,91 +231,88 @@
 			y: cards[i].y
 		});
 	}
 	// Shuffle positions array multiple times for more randomness
-	for (var shuffle = 0; shuffle < 3; shuffle++) {
+	for (var shuffle = 0; shuffle < 5; shuffle++) {
 		for (var i = positions.length - 1; i > 0; i--) {
 			var j = Math.floor(Math.random() * (i + 1));
 			var temp = positions[i];
 			positions[i] = positions[j];
 			positions[j] = temp;
 		}
 	}
-	// Create left and right swap positions for cards
-	var leftPositions = [];
-	var rightPositions = [];
-	for (var i = 0; i < cards.length; i++) {
-		leftPositions.push({
-			x: 200 + Math.random() * 400,
-			y: cards[i].y
-		});
-		rightPositions.push({
-			x: 1448 + Math.random() * 400,
-			y: cards[i].y
-		});
+	// Create multiple shuffle positions for more complex movement
+	var shufflePositions = [];
+	for (var phase = 0; phase < 4; phase++) {
+		var phasePositions = [];
+		for (var i = 0; i < cards.length; i++) {
+			phasePositions.push({
+				x: 300 + Math.random() * 1448,
+				y: 800 + Math.random() * 800,
+				rotation: -Math.PI / 3 + Math.random() * 2 * Math.PI / 3,
+				scaleX: 0.8 + Math.random() * 0.3,
+				scaleY: 0.8 + Math.random() * 0.3
+			});
+		}
+		shufflePositions.push(phasePositions);
 	}
-	// First phase: move cards to left positions
-	var phase1Completed = 0;
-	for (var i = 0; i < cards.length; i++) {
-		tween(cards[i], {
-			x: leftPositions[i].x,
-			y: leftPositions[i].y,
-			rotation: -Math.PI / 6 + Math.random() * Math.PI / 3,
-			scaleX: 0.9,
-			scaleY: 0.9
-		}, {
-			duration: 600,
-			easing: tween.easeInOut,
-			onFinish: function onFinish() {
-				phase1Completed++;
-				if (phase1Completed === cards.length) {
-					// Second phase: move cards to right positions
-					var phase2Completed = 0;
-					for (var j = 0; j < cards.length; j++) {
-						tween(cards[j], {
-							x: rightPositions[j].x,
-							y: rightPositions[j].y,
-							rotation: Math.PI / 6 + Math.random() * Math.PI / 3,
-							scaleX: 0.9,
-							scaleY: 0.9
-						}, {
-							duration: 800,
-							easing: tween.easeInOut,
-							onFinish: function onFinish() {
-								phase2Completed++;
-								if (phase2Completed === cards.length) {
-									// Third phase: move cards to final positions
-									var phase3Completed = 0;
-									for (var k = 0; k < cards.length; k++) {
-										tween(cards[k], {
-											x: positions[k].x,
-											y: positions[k].y,
-											rotation: 0,
-											scaleX: 1,
-											scaleY: 1
-										}, {
-											duration: 1000,
-											easing: tween.easeInOut,
-											onFinish: function onFinish() {
-												phase3Completed++;
-												if (phase3Completed === cards.length) {
-													// Re-enable cards after shuffle
-													for (var l = 0; l < cards.length; l++) {
-														cards[l].isClickable = true;
-													}
-													instructionText.setText('Find the green card!');
-												}
-											}
-										});
-									}
-								}
+	// Execute multiple shuffle phases
+	var currentPhase = 0;
+	var totalPhases = 4;
+	function executeShufflePhase() {
+		if (currentPhase >= totalPhases) {
+			// Final phase: move cards to final positions
+			var finalCompleted = 0;
+			for (var k = 0; k < cards.length; k++) {
+				tween(cards[k], {
+					x: positions[k].x,
+					y: positions[k].y,
+					rotation: 0,
+					scaleX: 1,
+					scaleY: 1
+				}, {
+					duration: 1200,
+					easing: tween.easeInOut,
+					onFinish: function onFinish() {
+						finalCompleted++;
+						if (finalCompleted === cards.length) {
+							// Re-enable cards after shuffle
+							for (var l = 0; l < cards.length; l++) {
+								cards[l].isClickable = true;
 							}
-						});
+							instructionText.setText('Find the green card!');
+						}
 					}
-				}
+				});
 			}
-		});
+			return;
+		}
+		// Execute current phase
+		var phaseCompleted = 0;
+		var currentPositions = shufflePositions[currentPhase];
+		for (var i = 0; i < cards.length; i++) {
+			tween(cards[i], {
+				x: currentPositions[i].x,
+				y: currentPositions[i].y,
+				rotation: currentPositions[i].rotation,
+				scaleX: currentPositions[i].scaleX,
+				scaleY: currentPositions[i].scaleY
+			}, {
+				duration: 500 + Math.random() * 400,
+				easing: tween.easeInOut,
+				onFinish: function onFinish() {
+					phaseCompleted++;
+					if (phaseCompleted === cards.length) {
+						currentPhase++;
+						// Small delay between phases
+						LK.setTimeout(executeShufflePhase, 200);
+					}
+				}
+			});
+		}
 	}
+	// Start shuffling
+	executeShufflePhase();
 }
 // Play background music
 LK.playMusic('bgMusic');
 // Initialize first level