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

/**** 
* Classes
****/ 
var GameBoard = Container.expand(function () {
	var self = Container.call(this);
	self.gridSize = 8;
	self.cellSize = 120;
	self.gems = [];
	self.selectedGem = null;
	self.isProcessing = false;
	// Create board background
	var boardBg = self.attachAsset('board', {
		anchorX: 0.5,
		anchorY: 0.5,
		scaleX: 1.5,
		scaleY: 1.5
	});
	self.initializeBoard = function () {
		// Create grid of gems
		for (var x = 0; x < self.gridSize; x++) {
			self.gems[x] = [];
			for (var y = 0; y < self.gridSize; y++) {
				var gemType = Math.floor(Math.random() * 6);
				var gem = new Gem(gemType, x, y);
				gem.x = (x - self.gridSize / 2 + 0.5) * self.cellSize;
				gem.y = (y - self.gridSize / 2 + 0.5) * self.cellSize;
				self.gems[x][y] = gem;
				self.addChild(gem);
			}
		}
		// Remove initial matches
		self.removeInitialMatches();
	};
	self.removeInitialMatches = function () {
		var hasMatches = true;
		while (hasMatches) {
			hasMatches = false;
			for (var x = 0; x < self.gridSize; x++) {
				for (var y = 0; y < self.gridSize; y++) {
					if (self.checkMatch(x, y).length >= 3) {
						// Replace with random different type
						var oldType = self.gems[x][y].gemType;
						var newType;
						do {
							newType = Math.floor(Math.random() * 6);
						} while (newType === oldType);
						self.gems[x][y].destroy();
						var newGem = new Gem(newType, x, y);
						newGem.x = (x - self.gridSize / 2 + 0.5) * self.cellSize;
						newGem.y = (y - self.gridSize / 2 + 0.5) * self.cellSize;
						self.gems[x][y] = newGem;
						self.addChild(newGem);
						hasMatches = true;
					}
				}
			}
		}
	};
	self.selectGem = function (gem) {
		if (self.isProcessing) return;
		if (self.selectedGem === null) {
			// First selection
			self.selectedGem = gem;
			gem.setSelected(true);
		} else if (self.selectedGem === gem) {
			// Deselect
			gem.setSelected(false);
			self.selectedGem = null;
		} else if (self.areAdjacent(self.selectedGem, gem)) {
			// Valid swap
			self.swapGems(self.selectedGem, gem);
		} else {
			// Select new gem
			self.selectedGem.setSelected(false);
			self.selectedGem = gem;
			gem.setSelected(true);
		}
	};
	self.areAdjacent = function (gem1, gem2) {
		var dx = Math.abs(gem1.gridX - gem2.gridX);
		var dy = Math.abs(gem1.gridY - gem2.gridY);
		return dx === 1 && dy === 0 || dx === 0 && dy === 1;
	};
	self.swapGems = function (gem1, gem2) {
		self.isProcessing = true;
		gem1.setSelected(false);
		gem2.setSelected(false);
		self.selectedGem = null;
		// Swap positions in grid
		var tempX = gem1.gridX;
		var tempY = gem1.gridY;
		gem1.gridX = gem2.gridX;
		gem1.gridY = gem2.gridY;
		gem2.gridX = tempX;
		gem2.gridY = tempY;
		self.gems[gem1.gridX][gem1.gridY] = gem1;
		self.gems[gem2.gridX][gem2.gridY] = gem2;
		// Animate swap
		var newX1 = (gem1.gridX - self.gridSize / 2 + 0.5) * self.cellSize;
		var newY1 = (gem1.gridY - self.gridSize / 2 + 0.5) * self.cellSize;
		var newX2 = (gem2.gridX - self.gridSize / 2 + 0.5) * self.cellSize;
		var newY2 = (gem2.gridY - self.gridSize / 2 + 0.5) * self.cellSize;
		var swapsCompleted = 0;
		function onSwapComplete() {
			swapsCompleted++;
			if (swapsCompleted === 2) {
				LK.getSound('swap').play();
				// Check for matches
				var matches1 = self.checkMatch(gem1.gridX, gem1.gridY);
				var matches2 = self.checkMatch(gem2.gridX, gem2.gridY);
				if (matches1.length >= 3 || matches2.length >= 3) {
					// Valid move
					self.processMatches();
				} else {
					// Invalid move - swap back
					self.swapGemsBack(gem1, gem2);
				}
			}
		}
		// Add golden glow during swap
		tween(gem1, {
			tint: 0xFFD700
		}, {
			duration: 100,
			onFinish: function onFinish() {
				tween(gem1, {
					tint: 0xFFFFFF
				}, {
					duration: 100
				});
			}
		});
		tween(gem2, {
			tint: 0xFFD700
		}, {
			duration: 100,
			onFinish: function onFinish() {
				tween(gem2, {
					tint: 0xFFFFFF
				}, {
					duration: 100
				});
			}
		});
		tween(gem1, {
			x: newX1,
			y: newY1
		}, {
			duration: 250,
			easing: tween.easeInOut,
			onFinish: onSwapComplete
		});
		tween(gem2, {
			x: newX2,
			y: newY2
		}, {
			duration: 250,
			easing: tween.easeInOut,
			onFinish: onSwapComplete
		});
	};
	self.swapGemsBack = function (gem1, gem2) {
		// Swap back in grid
		var tempX = gem1.gridX;
		var tempY = gem1.gridY;
		gem1.gridX = gem2.gridX;
		gem1.gridY = gem2.gridY;
		gem2.gridX = tempX;
		gem2.gridY = tempY;
		self.gems[gem1.gridX][gem1.gridY] = gem1;
		self.gems[gem2.gridX][gem2.gridY] = gem2;
		// Animate back
		var newX1 = (gem1.gridX - self.gridSize / 2 + 0.5) * self.cellSize;
		var newY1 = (gem1.gridY - self.gridSize / 2 + 0.5) * self.cellSize;
		var newX2 = (gem2.gridX - self.gridSize / 2 + 0.5) * self.cellSize;
		var newY2 = (gem2.gridY - self.gridSize / 2 + 0.5) * self.cellSize;
		var swapsCompleted = 0;
		function onSwapBackComplete() {
			swapsCompleted++;
			if (swapsCompleted === 2) {
				self.isProcessing = false;
			}
		}
		tween(gem1, {
			x: newX1,
			y: newY1
		}, {
			duration: 200,
			onFinish: onSwapBackComplete
		});
		tween(gem2, {
			x: newX2,
			y: newY2
		}, {
			duration: 200,
			onFinish: onSwapBackComplete
		});
	};
	self.checkMatch = function (x, y) {
		var matches = [{
			x: x,
			y: y
		}];
		var gemType = self.gems[x][y].gemType;
		// Check horizontal
		var left = x - 1;
		while (left >= 0 && self.gems[left][y].gemType === gemType) {
			matches.push({
				x: left,
				y: y
			});
			left--;
		}
		var right = x + 1;
		while (right < self.gridSize && self.gems[right][y].gemType === gemType) {
			matches.push({
				x: right,
				y: y
			});
			right++;
		}
		if (matches.length >= 3) return matches;
		// Check vertical
		matches = [{
			x: x,
			y: y
		}];
		var up = y - 1;
		while (up >= 0 && self.gems[x][up].gemType === gemType) {
			matches.push({
				x: x,
				y: up
			});
			up--;
		}
		var down = y + 1;
		while (down < self.gridSize && self.gems[x][down].gemType === gemType) {
			matches.push({
				x: x,
				y: down
			});
			down++;
		}
		return matches.length >= 3 ? matches : [];
	};
	self.processMatches = function () {
		var allMatches = [];
		// Find all matches
		for (var x = 0; x < self.gridSize; x++) {
			for (var y = 0; y < self.gridSize; y++) {
				var matches = self.checkMatch(x, y);
				if (matches.length >= 3) {
					allMatches = allMatches.concat(matches);
				}
			}
		}
		if (allMatches.length === 0) {
			self.isProcessing = false;
			return;
		}
		// Remove duplicates
		var uniqueMatches = [];
		for (var i = 0; i < allMatches.length; i++) {
			var found = false;
			for (var j = 0; j < uniqueMatches.length; j++) {
				if (uniqueMatches[j].x === allMatches[i].x && uniqueMatches[j].y === allMatches[i].y) {
					found = true;
					break;
				}
			}
			if (!found) {
				uniqueMatches.push(allMatches[i]);
			}
		}
		// Animate matched gems
		var animationsCompleted = 0;
		function onMatchComplete() {
			animationsCompleted++;
			if (animationsCompleted === uniqueMatches.length) {
				LK.getSound('match').play();
				LK.setScore(LK.getScore() + uniqueMatches.length * 10);
				scoreText.setText(LK.getScore());
				self.dropGems();
			}
		}
		for (var i = 0; i < uniqueMatches.length; i++) {
			var match = uniqueMatches[i];
			self.gems[match.x][match.y].animateMatch(onMatchComplete);
		}
	};
	self.dropGems = function () {
		var dropsCompleted = 0;
		var totalDrops = 0;
		for (var x = 0; x < self.gridSize; x++) {
			var writeIndex = self.gridSize - 1;
			// Move non-matched gems down
			for (var y = self.gridSize - 1; y >= 0; y--) {
				if (!self.gems[x][y].isMatched) {
					if (y !== writeIndex) {
						self.gems[x][writeIndex] = self.gems[x][y];
						self.gems[x][writeIndex].gridY = writeIndex;
						var newY = (writeIndex - self.gridSize / 2 + 0.5) * self.cellSize;
						totalDrops++;
						(function (gem, targetY) {
							gem.animateFall(targetY, function () {
								dropsCompleted++;
								if (dropsCompleted === totalDrops) {
									self.fillEmptySpaces();
								}
							});
						})(self.gems[x][writeIndex], newY);
					}
					writeIndex--;
				}
			}
			// Create new gems for empty spaces
			for (var y = 0; y <= writeIndex; y++) {
				var gemType = Math.floor(Math.random() * 6);
				var newGem = new Gem(gemType, x, y);
				newGem.x = (x - self.gridSize / 2 + 0.5) * self.cellSize;
				newGem.y = (y - self.gridSize / 2 + 0.5) * self.cellSize - 960;
				self.gems[x][y] = newGem;
				self.addChild(newGem);
				var finalY = (y - self.gridSize / 2 + 0.5) * self.cellSize;
				totalDrops++;
				(function (gem, targetY) {
					gem.animateFall(targetY, function () {
						dropsCompleted++;
						if (dropsCompleted === totalDrops) {
							self.fillEmptySpaces();
						}
					});
				})(newGem, finalY);
			}
		}
		if (totalDrops === 0) {
			self.fillEmptySpaces();
		}
	};
	self.fillEmptySpaces = function () {
		// Check for new matches
		LK.setTimeout(function () {
			self.processMatches();
		}, 100);
	};
	return self;
});
// Create score display
var Gem = Container.expand(function (type, gridX, gridY) {
	var self = Container.call(this);
	self.gemType = type;
	self.gridX = gridX;
	self.gridY = gridY;
	self.isSelected = false;
	self.isMatched = false;
	// Gem asset types
	var assetNames = ['scarab', 'ankh', 'pyramid', 'coin', 'papyrus', 'eye'];
	var assetName = assetNames[type];
	var gemGraphics = self.attachAsset(assetName, {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Selection highlight
	var highlight = self.attachAsset('cell', {
		anchorX: 0.5,
		anchorY: 0.5,
		alpha: 0
	});
	highlight.tint = 0xFFFFFF;
	self.setSelected = function (selected) {
		self.isSelected = selected;
		if (selected) {
			// Glowing white highlight effect
			tween(highlight, {
				alpha: 0.8
			}, {
				duration: 200
			});
			tween(self, {
				scaleX: 1.2,
				scaleY: 1.2
			}, {
				duration: 200,
				easing: tween.easeOut
			});
		} else {
			tween(highlight, {
				alpha: 0
			}, {
				duration: 200
			});
			tween(self, {
				scaleX: 1,
				scaleY: 1
			}, {
				duration: 200,
				easing: tween.easeOut
			});
		}
	};
	self.animateMatch = function (callback) {
		self.isMatched = true;
		// First scale up with glow effect
		tween(self, {
			scaleX: 1.3,
			scaleY: 1.3,
			alpha: 1
		}, {
			duration: 150,
			easing: tween.easeOut,
			onFinish: function onFinish() {
				// Then fade out while scaling larger
				tween(self, {
					alpha: 0,
					scaleX: 2.0,
					scaleY: 2.0
				}, {
					duration: 200,
					easing: tween.easeIn,
					onFinish: callback
				});
			}
		});
	};
	self.animateFall = function (newY, callback) {
		tween(self, {
			y: newY
		}, {
			duration: 400,
			easing: tween.bounceOut,
			onFinish: function onFinish() {
				// Small bounce when landing
				tween(self, {
					scaleX: 1.1,
					scaleY: 1.1
				}, {
					duration: 100,
					easing: tween.easeOut,
					onFinish: function onFinish() {
						tween(self, {
							scaleX: 1,
							scaleY: 1
						}, {
							duration: 100,
							easing: tween.easeOut,
							onFinish: callback
						});
					}
				});
			}
		});
	};
	self.down = function (x, y, obj) {
		if (!self.isMatched) {
			gameBoard.selectGem(self);
		}
	};
	return self;
});

/**** 
* Initialize Game
****/ 
var game = new LK.Game({
	backgroundColor: 0x8B4513 // Sandy brown Egyptian theme
});

/**** 
* Game Code
****/ 
// Create score display
// Egyptian-themed gem assets
// Game board background
// Sound effects
var scoreText = new Text2('Score: 0', {
	size: 60,
	fill: 0xFFD700
});
scoreText.anchor.set(0.5, 0);
LK.gui.top.addChild(scoreText);
// Create level display
var levelText = new Text2('Level 1', {
	size: 50,
	fill: 0xFFD700
});
levelText.anchor.set(0.5, 0);
levelText.y = 100;
LK.gui.top.addChild(levelText);
// Create target score display
var targetText = new Text2('Target: 1000', {
	size: 40,
	fill: 0xFFFFFF
});
targetText.anchor.set(1, 0);
targetText.y = 100;
LK.gui.topRight.addChild(targetText);
// Create instruction text
var instructionText = new Text2('Tap gems to select, then tap adjacent gem to swap', {
	size: 35,
	fill: 0xFFD700
});
instructionText.anchor.set(0.5, 1);
instructionText.y = -50;
LK.gui.bottom.addChild(instructionText);
// Game variables
var currentLevel = 1;
var targetScore = 1000;
var gameBoard;
// Initialize game board
gameBoard = game.addChild(new GameBoard());
gameBoard.x = 2048 / 2;
gameBoard.y = 2732 / 2;
gameBoard.initializeBoard();
// Update score display
function updateScore() {
	scoreText.setText('Score: ' + LK.getScore());
	// Check if level completed
	if (LK.getScore() >= targetScore) {
		currentLevel++;
		targetScore = currentLevel * 1000;
		levelText.setText('Level ' + currentLevel);
		targetText.setText('Target: ' + targetScore);
		LK.getSound('levelComplete').play();
		// Golden flash effect for level completion
		LK.effects.flashScreen(0xFFD700, 800);
		// Animate score text celebration
		tween(scoreText, {
			scaleX: 1.3,
			scaleY: 1.3
		}, {
			duration: 300,
			easing: tween.easeOut,
			onFinish: function onFinish() {
				tween(scoreText, {
					scaleX: 1,
					scaleY: 1
				}, {
					duration: 200,
					easing: tween.easeOut
				});
			}
		});
		// Show win condition at level 10
		if (currentLevel > 10) {
			LK.showYouWin();
		}
	}
}
// Game update loop
game.update = function () {
	// Update displays
	if (LK.ticks % 30 === 0) {
		updateScore();
	}
};

===================================================================
--- original.js
+++ change.js
@@ -16,10 +16,10 @@
 	// Create board background
 	var boardBg = self.attachAsset('board', {
 		anchorX: 0.5,
 		anchorY: 0.5,
-		scaleX: 0.8,
-		scaleY: 0.8
+		scaleX: 1.5,
+		scaleY: 1.5
 	});
 	self.initializeBoard = function () {
 		// Create grid of gems
 		for (var x = 0; x < self.gridSize; x++) {