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

/**** 
* Classes
****/ 
var GridCell = Container.expand(function () {
	var self = Container.call(this);
	// Create the background square for the cell
	var background = self.attachAsset('cuadricula', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Initialize properties
	self.value = 0;
	self.sprite = null;
	self.row = -1; // Initialize row property
	self.col = -1; // Initialize col property
	// Method to set value and corresponding sprite
	self.setValue = function (newValue) {
		self.value = newValue;
		// Remove previous sprite if exists
		if (self.sprite) {
			self.removeChild(self.sprite);
		}
		// Create new sprite based on value
		var spriteId = 'meme' + newValue;
		self.sprite = LK.getAsset(spriteId, {
			anchorX: 0.5,
			anchorY: 0.5
		});
		self.addChild(self.sprite);
	};
	self.down = function (x, y, obj) {
		handleCellTap(self);
	};
	return self;
});

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

/**** 
* Game Code
****/ 
// Grid configuration
var selectedCell = null;
function handleCellTap(tappedCell) {
	if (selectedCell === null) {
		selectedCell = tappedCell;
		LK.effects.flashObject(selectedCell.sprite, 0xFFFF00, 150); // Flash yellow quickly
	} else {
		var cell1 = selectedCell;
		var cell2 = tappedCell;
		if (cell1 === cell2) {
			// Tapped the same selected cell again
			selectedCell = null; // Deselect
		} else {
			// Check for adjacency (vertical or horizontal)
			var isAdjacent = Math.abs(cell1.row - cell2.row) === 1 && cell1.col === cell2.col || Math.abs(cell1.col - cell2.col) === 1 && cell1.row === cell2.row;
			if (isAdjacent) {
				// Store original positions for animation
				var pos1_x = cell1.x;
				var pos1_y = cell1.y;
				var pos2_x = cell2.x;
				var pos2_y = cell2.y;
				// Store original grid indices
				var row1 = cell1.row;
				var col1 = cell1.col;
				var row2 = cell2.row;
				var col2 = cell2.col;
				// Swap cells in the gridCells array
				gridCells[row1][col1] = cell2;
				gridCells[row2][col2] = cell1;
				// Swap row/col properties on the cell objects
				cell1.row = row2;
				cell1.col = col2;
				cell2.row = row1;
				cell2.col = col1;
				// Animate the visual swap of positions
				tween(cell1, {
					x: pos2_x,
					y: pos2_y
				}, {
					duration: 300
				});
				tween(cell2, {
					x: pos1_x,
					y: pos1_y
				}, {
					duration: 300
				});
				selectedCell = null; // Reset selection after swap
				// Schedule the match check and destruction slightly after the animation completes
				LK.setTimeout(function () {
					checkForAndDestroyMatches(cell1, cell2); // Pass the swapped cells
					// Future enhancement: After destruction, new cells might fall,
					// and new matches could form. This would require a loop of:
					// check/destroy -> fill -> check/destroy ... until no more matches.
					// For now, we just check once after the swap.
				}, 350); // Animation is 300ms, add a small buffer of 50ms
			} else {
				// Tapped a non-adjacent cell. Treat this as a new selection.
				selectedCell = tappedCell;
				LK.effects.flashObject(selectedCell.sprite, 0xFFFF00, 150); // Flash the new selection
			}
		}
	}
}
// Helper functions for match detection and destruction
function getMatches() {
	var matches = [];
	var r, c, k, cell1, nextCell, currentMatchValue, currentMatchCells;
	// Horizontal matches
	for (r = 0; r < gridSize; r++) {
		for (c = 0; c < gridSize;) {
			// c is incremented based on match length or by 1
			if (c > gridSize - 3) {
				// Optimization: not enough cells left for a match of 3
				c++;
				continue;
			}
			cell1 = gridCells[r][c];
			if (!cell1) {
				// Skip empty cells
				c++;
				continue;
			}
			currentMatchValue = cell1.value;
			currentMatchCells = [cell1];
			for (k = c + 1; k < gridSize; k++) {
				nextCell = gridCells[r][k];
				if (nextCell && nextCell.value === currentMatchValue) {
					currentMatchCells.push(nextCell);
				} else {
					break; // End of current potential match
				}
			}
			if (currentMatchCells.length >= 3) {
				matches.push(currentMatchCells);
			}
			c += currentMatchCells.length > 0 ? currentMatchCells.length : 1; // Advance index
		}
	}
	// Vertical matches
	for (c = 0; c < gridSize; c++) {
		for (r = 0; r < gridSize;) {
			// r is incremented based on match length or by 1
			if (r > gridSize - 3) {
				// Optimization: not enough cells left for a match of 3
				r++;
				continue;
			}
			cell1 = gridCells[r][c];
			if (!cell1) {
				// Skip empty cells
				r++;
				continue;
			}
			currentMatchValue = cell1.value;
			currentMatchCells = [cell1];
			for (k = r + 1; k < gridSize; k++) {
				nextCell = gridCells[k][c];
				if (nextCell && nextCell.value === currentMatchValue) {
					currentMatchCells.push(nextCell);
				} else {
					break; // End of current potential match
				}
			}
			if (currentMatchCells.length >= 3) {
				matches.push(currentMatchCells);
			}
			r += currentMatchCells.length > 0 ? currentMatchCells.length : 1; // Advance index
		}
	}
	return matches;
}
function destroyCells(cellsToDestroy) {
	cellsToDestroy.forEach(function (cell) {
		// Defensive checks: ensure cell exists and is the one we expect in the grid
		if (cell && gridCells[cell.row] && gridCells[cell.row][cell.col] === cell) {
			gridContainer.removeChild(cell); // Remove from display
			cell.destroy(); // Destroy the cell object (releases resources)
			gridCells[cell.row][cell.col] = null; // Mark as empty in the logical grid
		}
	});
}
function checkForAndDestroyMatches(swappedCellA, swappedCellB) {
	var allMatchGroupsOnBoard = getMatches(); // Get all potential matches on the board
	if (allMatchGroupsOnBoard.length === 0) {
		return; // No matches found anywhere, nothing to do
	}
	var relevantMatchGroups = [];
	// Filter allMatchGroupsOnBoard to find groups containing one of the swapped cells
	allMatchGroupsOnBoard.forEach(function (group) {
		var groupIsRelevant = false;
		for (var i = 0; i < group.length; i++) {
			var cellInGroup = group[i];
			// Check if the current cell in the group is one of the cells that was moved
			if (cellInGroup === swappedCellA || cellInGroup === swappedCellB) {
				groupIsRelevant = true;
				break; // Found a swapped cell in this group, so the group is relevant
			}
		}
		if (groupIsRelevant) {
			relevantMatchGroups.push(group);
		}
	});
	if (relevantMatchGroups.length === 0) {
		return; // No matches involving the swapped cells were found
	}
	// Proceed with destroying cells from the relevant match groups
	var cellsToDestroy = [];
	var uniqueCellTracker = {}; // To ensure each cell is added only once
	relevantMatchGroups.forEach(function (group) {
		// Iterate over only relevant groups
		group.forEach(function (cell) {
			// Create a unique key for each cell using its row and column
			var cellKey = cell.row + "_" + cell.col;
			if (!uniqueCellTracker[cellKey]) {
				cellsToDestroy.push(cell);
				uniqueCellTracker[cellKey] = true;
			}
		});
	});
	if (cellsToDestroy.length > 0) {
		destroyCells(cellsToDestroy);
		// Here you could add scoring or other effects if needed
		// e.g., LK.setScore(LK.getScore() + cellsToDestroy.length * 10);
	}
}
var gridSize = 9;
var cellSpacing = 10;
var cellSize = 160; // Width/height of the cell background
var gridCells = [];
// Calculate total grid width and height
var totalGridWidth = gridSize * cellSize + (gridSize - 1) * cellSpacing;
var totalGridHeight = totalGridWidth; // Grid is square
// Calculate starting position to center the grid
var startX = (2048 - totalGridWidth) / 2 + cellSize / 2;
var startY = (2732 - totalGridHeight) / 2 + cellSize / 2;
// Create grid container
var gridContainer = new Container();
game.addChild(gridContainer);
// Create grid cells
for (var row = 0; row < gridSize; row++) {
	gridCells[row] = [];
	for (var col = 0; col < gridSize; col++) {
		// Create new cell
		var cell = new GridCell();
		// Position cell
		cell.x = startX + col * (cellSize + cellSpacing);
		cell.y = startY + row * (cellSize + cellSpacing);
		// Assign row and column to the cell
		cell.row = row;
		cell.col = col;
		// Generate random value between 1 and 5
		var randomValue = Math.floor(Math.random() * 5) + 1;
		cell.setValue(randomValue);
		// Add to grid container and store reference
		gridContainer.addChild(cell);
		gridCells[row][col] = cell;
	}
}

===================================================================
--- original.js
+++ change.js
@@ -99,9 +99,9 @@
 				});
 				selectedCell = null; // Reset selection after swap
 				// Schedule the match check and destruction slightly after the animation completes
 				LK.setTimeout(function () {
-					checkForAndDestroyMatches();
+					checkForAndDestroyMatches(cell1, cell2); // Pass the swapped cells
 					// Future enhancement: After destruction, new cells might fall,
 					// and new matches could form. This would require a loop of:
 					// check/destroy -> fill -> check/destroy ... until no more matches.
 					// For now, we just check once after the swap.
@@ -191,16 +191,37 @@
 			gridCells[cell.row][cell.col] = null; // Mark as empty in the logical grid
 		}
 	});
 }
-function checkForAndDestroyMatches() {
-	var matchGroups = getMatches();
-	if (matchGroups.length === 0) {
-		return; // No matches found, nothing to do
+function checkForAndDestroyMatches(swappedCellA, swappedCellB) {
+	var allMatchGroupsOnBoard = getMatches(); // Get all potential matches on the board
+	if (allMatchGroupsOnBoard.length === 0) {
+		return; // No matches found anywhere, nothing to do
 	}
+	var relevantMatchGroups = [];
+	// Filter allMatchGroupsOnBoard to find groups containing one of the swapped cells
+	allMatchGroupsOnBoard.forEach(function (group) {
+		var groupIsRelevant = false;
+		for (var i = 0; i < group.length; i++) {
+			var cellInGroup = group[i];
+			// Check if the current cell in the group is one of the cells that was moved
+			if (cellInGroup === swappedCellA || cellInGroup === swappedCellB) {
+				groupIsRelevant = true;
+				break; // Found a swapped cell in this group, so the group is relevant
+			}
+		}
+		if (groupIsRelevant) {
+			relevantMatchGroups.push(group);
+		}
+	});
+	if (relevantMatchGroups.length === 0) {
+		return; // No matches involving the swapped cells were found
+	}
+	// Proceed with destroying cells from the relevant match groups
 	var cellsToDestroy = [];
 	var uniqueCellTracker = {}; // To ensure each cell is added only once
-	matchGroups.forEach(function (group) {
+	relevantMatchGroups.forEach(function (group) {
+		// Iterate over only relevant groups
 		group.forEach(function (cell) {
 			// Create a unique key for each cell using its row and column
 			var cellKey = cell.row + "_" + cell.col;
 			if (!uniqueCellTracker[cellKey]) {