===================================================================
--- original.js
+++ change.js
@@ -1,6 +1,471 @@
-/****
+/**** 
+* Plugins
+****/ 
+var tween = LK.import("@upit/tween.v1");
+
+/**** 
+* Classes
+****/ 
+var GameBoard = Container.expand(function () {
+	var self = Container.call(this);
+	self.gridSize = 8;
+	self.cellSize = 80;
+	self.gems = [];
+	self.selectedGem = null;
+	self.isProcessing = false;
+	// Create board background
+	var boardBg = self.attachAsset('board', {
+		anchorX: 0.5,
+		anchorY: 0.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);
+				}
+			}
+		}
+		tween(gem1, {
+			x: newX1,
+			y: newY1
+		}, {
+			duration: 200,
+			onFinish: onSwapComplete
+		});
+		tween(gem2, {
+			x: newX2,
+			y: newY2
+		}, {
+			duration: 200,
+			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 - 640;
+				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) {
+			tween(highlight, {
+				alpha: 0.5
+			}, {
+				duration: 200
+			});
+			tween(self, {
+				scaleX: 1.1,
+				scaleY: 1.1
+			}, {
+				duration: 200
+			});
+		} else {
+			tween(highlight, {
+				alpha: 0
+			}, {
+				duration: 200
+			});
+			tween(self, {
+				scaleX: 1,
+				scaleY: 1
+			}, {
+				duration: 200
+			});
+		}
+	};
+	self.animateMatch = function (callback) {
+		self.isMatched = true;
+		tween(self, {
+			alpha: 0,
+			scaleX: 1.5,
+			scaleY: 1.5
+		}, {
+			duration: 300,
+			easing: tween.easeOut,
+			onFinish: callback
+		});
+	};
+	self.animateFall = function (newY, callback) {
+		tween(self, {
+			y: newY
+		}, {
+			duration: 300,
+			easing: tween.bounceOut,
+			onFinish: callback
+		});
+	};
+	self.down = function (x, y, obj) {
+		if (!self.isMatched) {
+			gameBoard.selectGem(self);
+		}
+	};
+	return self;
+});
+
+/**** 
 * Initialize Game
-****/
+****/ 
 var game = new LK.Game({
-	backgroundColor: 0x000000
-});
\ No newline at end of file
+	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, 0);
+levelText.y = 100;
+LK.gui.topLeft.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);
+// 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();
+		LK.effects.flashScreen(0xFFD700, 500);
+		// 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();
+	}
+};
\ No newline at end of file