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

/**** 
* Classes
****/ 
var Card = Container.expand(function (symbolType) {
	var self = Container.call(this);
	self.symbolType = symbolType;
	self.isRevealed = false;
	self.isMatched = false;
	// Card background
	var cardBack = self.attachAsset('cardBack', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Card front (hidden initially)
	var cardFront = self.attachAsset('cardFront', {
		anchorX: 0.5,
		anchorY: 0.5,
		alpha: 0
	});
	// Symbol (hidden initially)
	var symbol = self.attachAsset('symbol' + symbolType, {
		anchorX: 0.5,
		anchorY: 0.5,
		alpha: 0
	});
	self.reveal = function () {
		if (self.isRevealed || self.isMatched) return;
		self.isRevealed = true;
		LK.getSound('cardFlip').play();
		// Animate card flip
		tween(cardBack, {
			alpha: 0
		}, {
			duration: 200
		});
		tween(cardFront, {
			alpha: 1
		}, {
			duration: 200
		});
		tween(symbol, {
			alpha: 1
		}, {
			duration: 200
		});
	};
	self.hide = function () {
		if (!self.isRevealed || self.isMatched) return;
		self.isRevealed = false;
		// Animate card flip back
		tween(cardBack, {
			alpha: 1
		}, {
			duration: 200
		});
		tween(cardFront, {
			alpha: 0
		}, {
			duration: 200
		});
		tween(symbol, {
			alpha: 0
		}, {
			duration: 200
		});
	};
	self.setMatched = function () {
		self.isMatched = true;
		self.isRevealed = true;
		// Flash green to indicate match
		tween(cardFront, {
			tint: 0x4CAF50
		}, {
			duration: 300,
			onFinish: function onFinish() {
				tween(cardFront, {
					tint: 0xFFFFFF
				}, {
					duration: 300
				});
			}
		});
		tween(symbol, {
			tint: 0x4CAF50
		}, {
			duration: 300,
			onFinish: function onFinish() {
				tween(symbol, {
					tint: 0xFFFFFF
				}, {
					duration: 300
				});
			}
		});
	};
	self.down = function (x, y, obj) {
		if (gameState !== 'playing') return;
		if (self.isMatched) return;
		if (!self.isRevealed) {
			if (revealedCards.length < 2) {
				// Create egg cracking animation
				var eggCrack = LK.getAsset('eggCrack', {
					anchorX: 0.5,
					anchorY: 0.5,
					alpha: 0.8,
					scaleX: 0.5,
					scaleY: 0.5
				});
				eggCrack.x = self.x;
				eggCrack.y = self.y;
				game.addChild(eggCrack);
				// Animate egg cracking effect
				tween(eggCrack, {
					scaleX: 1.2,
					scaleY: 1.2,
					alpha: 0
				}, {
					duration: 300,
					easing: tween.easeOut,
					onFinish: function onFinish() {
						eggCrack.destroy();
						// Reveal card after egg animation
						self.reveal();
					}
				});
				revealedCards.push(self);
				if (revealedCards.length === 2) {
					LK.setTimeout(function () {
						checkMatch();
					}, 350); // Wait for egg animation to complete
				}
			}
		}
	};
	return self;
});

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

/**** 
* Game Code
****/ 
var gameState = 'playing';
var cards = [];
var revealedCards = [];
var matchedPairs = 0;
var totalPairs = 18;
// Create symbol pairs array
var symbolPairs = [];
for (var i = 1; i <= totalPairs; i++) {
	symbolPairs.push(i);
	symbolPairs.push(i);
}
// Shuffle the symbol pairs
function shuffleArray(array) {
	for (var i = array.length - 1; i > 0; i--) {
		var j = Math.floor(Math.random() * (i + 1));
		var temp = array[i];
		array[i] = array[j];
		array[j] = temp;
	}
}
shuffleArray(symbolPairs);
// Create 6x6 grid of cards
var cardSize = 280;
var cardSpacing = 20; // Add margin between cards
var gridSize = 6;
var totalGridWidth = gridSize * cardSize + (gridSize - 1) * cardSpacing;
var totalGridHeight = gridSize * cardSize + (gridSize - 1) * cardSpacing;
var startX = (2048 - totalGridWidth) / 2 + cardSize / 2;
var startY = (2732 - totalGridHeight) / 2 + cardSize / 2;
for (var row = 0; row < gridSize; row++) {
	for (var col = 0; col < gridSize; col++) {
		var cardIndex = row * gridSize + col;
		var card = new Card(symbolPairs[cardIndex]);
		card.x = startX + col * (cardSize + cardSpacing);
		card.y = startY + row * (cardSize + cardSpacing);
		cards.push(card);
		game.addChild(card);
	}
}
// Draw horizontal grid lines
for (var row = 0; row <= gridSize; row++) {
	var lineY = startY - cardSize / 2 + row * (cardSize + cardSpacing) - cardSpacing / 2;
	for (var x = startX - cardSize / 2; x < startX - cardSize / 2 + totalGridWidth; x += 10) {
		var horizontalLine = LK.getAsset('gridLine', {
			anchorX: 0.5,
			anchorY: 0.5,
			scaleX: 2.5,
			scaleY: 1
		});
		horizontalLine.x = x;
		horizontalLine.y = lineY;
		game.addChild(horizontalLine);
	}
}
// Draw vertical grid lines  
for (var col = 0; col <= gridSize; col++) {
	var lineX = startX - cardSize / 2 + col * (cardSize + cardSpacing) - cardSpacing / 2;
	for (var y = startY - cardSize / 2; y < startY - cardSize / 2 + totalGridHeight; y += 10) {
		var verticalLine = LK.getAsset('gridLine', {
			anchorX: 0.5,
			anchorY: 0.5,
			scaleX: 1,
			scaleY: 2.5
		});
		verticalLine.x = lineX;
		verticalLine.y = y;
		game.addChild(verticalLine);
	}
}
// Timer and score variables
var timeRemaining = 60; // Start with 60 seconds
var lastTimeUpdate = Date.now();
// Score display - left upper corner
var scoreTxt = new Text2('Matches: 0', {
	size: 80,
	fill: 0xFFFFFF
});
scoreTxt.anchor.set(0, 0);
scoreTxt.x = 120; // Offset from left edge to avoid menu icon
scoreTxt.y = 50;
LK.gui.topLeft.addChild(scoreTxt);
// Timer display - right upper corner
var timerTxt = new Text2('Time: 60s', {
	size: 80,
	fill: 0xFF6B6B
});
timerTxt.anchor.set(1, 0);
timerTxt.x = -50; // Offset from right edge
timerTxt.y = 50;
LK.gui.topRight.addChild(timerTxt);
// Title - bottom middle of screen
var titleTxt = new Text2('Memory Matrix 8-Bit', {
	size: 100,
	fill: 0xFFD700
});
titleTxt.anchor.set(0.5, 1);
titleTxt.x = 0;
titleTxt.y = -50; // Position at bottom with small margin
LK.gui.bottom.addChild(titleTxt);
function checkMatch() {
	if (revealedCards.length !== 2) return;
	var card1 = revealedCards[0];
	var card2 = revealedCards[1];
	LK.setTimeout(function () {
		if (card1.symbolType === card2.symbolType) {
			// Match found - keep cards revealed
			card1.setMatched();
			card2.setMatched();
			matchedPairs++;
			// Add 10 seconds to timer for each match
			timeRemaining += 10;
			timerTxt.setText('Time: ' + timeRemaining + 's');
			LK.getSound('match').play();
			LK.setScore(matchedPairs);
			scoreTxt.setText('Matches: ' + matchedPairs);
			// Check for victory
			if (matchedPairs === totalPairs) {
				gameState = 'won';
				LK.setTimeout(function () {
					LK.showYouWin();
				}, 1000);
			}
		} else {
			// No match - hide cards automatically
			card1.hide();
			card2.hide();
		}
		revealedCards = [];
	}, 1000);
}
game.update = function () {
	// Update timer countdown
	if (gameState === 'playing') {
		var currentTime = Date.now();
		if (currentTime - lastTimeUpdate >= 1000) {
			// Update every second
			timeRemaining--;
			timerTxt.setText('Time: ' + timeRemaining + 's');
			lastTimeUpdate = currentTime;
			// Check if time is up
			if (timeRemaining <= 0) {
				gameState = 'gameOver';
				LK.showGameOver();
			}
		}
	}
};

===================================================================
--- original.js
+++ change.js
@@ -102,12 +102,38 @@
 		if (gameState !== 'playing') return;
 		if (self.isMatched) return;
 		if (!self.isRevealed) {
 			if (revealedCards.length < 2) {
-				self.reveal();
+				// Create egg cracking animation
+				var eggCrack = LK.getAsset('eggCrack', {
+					anchorX: 0.5,
+					anchorY: 0.5,
+					alpha: 0.8,
+					scaleX: 0.5,
+					scaleY: 0.5
+				});
+				eggCrack.x = self.x;
+				eggCrack.y = self.y;
+				game.addChild(eggCrack);
+				// Animate egg cracking effect
+				tween(eggCrack, {
+					scaleX: 1.2,
+					scaleY: 1.2,
+					alpha: 0
+				}, {
+					duration: 300,
+					easing: tween.easeOut,
+					onFinish: function onFinish() {
+						eggCrack.destroy();
+						// Reveal card after egg animation
+						self.reveal();
+					}
+				});
 				revealedCards.push(self);
 				if (revealedCards.length === 2) {
-					checkMatch();
+					LK.setTimeout(function () {
+						checkMatch();
+					}, 350); // Wait for egg animation to complete
 				}
 			}
 		}
 	};