/**** 
* 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 cellsPendingPhysicalDestruction = [];
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
			}
		}
	}
}
// Function to actually remove cells from display and destroy them
function actuallyDestroyCells(arrayOfCells) {
	arrayOfCells.forEach(function (cell) {
		if (cell && cell.parent) {
			// Check if cell exists and is still attached
			gridContainer.removeChild(cell);
		}
		if (cell) {
			// Check if cell exists before destroying
			cell.destroy();
		}
	});
}
// 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 to animate falling cells and trigger further checks
function animateFallingCellsAndTriggerCascade() {
	var cellsToShiftVisualOnly = [];
	var gridUpdates = []; // To store { cell, oldRow, oldCol, newRow, newCol }
	for (var c = 0; c < gridSize; c++) {
		// Iterate columns
		var emptySlotsInColumn = 0;
		for (var r = gridSize - 1; r >= 0; r--) {
			// Iterate rows from bottom up
			if (gridCells[r][c] === null) {
				emptySlotsInColumn++;
			} else if (emptySlotsInColumn > 0) {
				var cellToMove = gridCells[r][c];
				var newLogicalRow = r + emptySlotsInColumn;
				var targetY = startY + newLogicalRow * (cellSize + cellSpacing);
				cellsToShiftVisualOnly.push({
					cell: cellToMove,
					targetY: targetY
				});
				// Store details needed to update the logical grid
				gridUpdates.push({
					cell: cellToMove,
					oldRow: r,
					oldCol: c,
					newRow: newLogicalRow,
					newCol: c
				});
			}
		}
	}
	// Apply logical grid updates *before* animation starts
	// First, clear old positions of moving cells to avoid overwriting during update
	gridUpdates.forEach(function (op) {
		gridCells[op.oldRow][op.oldCol] = null;
	});
	// Then, place cells in their new logical positions and update their row property
	gridUpdates.forEach(function (op) {
		op.cell.row = op.newRow; // Update cell's internal knowledge of its row
		gridCells[op.newRow][op.newCol] = op.cell;
	});
	if (cellsToShiftVisualOnly.length === 0) {
		// No cells are moving, meaning falling is complete for this cascade step, or no fall was needed.
		if (cellsPendingPhysicalDestruction.length > 0) {
			actuallyDestroyCells(cellsPendingPhysicalDestruction);
			cellsPendingPhysicalDestruction = []; // Clear the list
		}
		// Check for new matches on the entire board.
		// Use LK.setTimeout to ensure this check happens after current execution context unwinds.
		LK.setTimeout(function () {
			checkForAndDestroyMatches(null, null); // Check entire board for new matches
		}, 50); // A small delay
		return;
	}
	var animationsInProgressCount = cellsToShiftVisualOnly.length;
	cellsToShiftVisualOnly.forEach(function (shiftOp) {
		tween(shiftOp.cell, {
			y: shiftOp.targetY
		}, {
			duration: 300,
			// Animation duration
			easing: tween.easeOut,
			// A smooth easing for falling
			onFinish: function onFinish() {
				animationsInProgressCount--;
				if (animationsInProgressCount === 0) {
					// All falling animations for this step are done
					if (cellsPendingPhysicalDestruction.length > 0) {
						actuallyDestroyCells(cellsPendingPhysicalDestruction);
						cellsPendingPhysicalDestruction = []; // Clear the list
					}
					// Now, check for new matches formed by the fallen cells
					LK.setTimeout(function () {
						checkForAndDestroyMatches(null, null); // Recursive call for cascades
					}, 50); // A small delay
				}
			}
		});
	});
}
function checkForAndDestroyMatches(swappedCellA, swappedCellB) {
	var allMatchGroupsOnBoard = getMatches();
	var relevantMatchGroups = [];
	if (swappedCellA === null && swappedCellB === null) {
		// Full board check for cascades
		relevantMatchGroups = allMatchGroupsOnBoard;
	} else {
		// Initial check after a swap
		allMatchGroupsOnBoard.forEach(function (group) {
			var groupIsRelevant = false;
			for (var i = 0; i < group.length; i++) {
				var cellInGroup = group[i];
				if (cellInGroup === swappedCellA || cellInGroup === swappedCellB) {
					groupIsRelevant = true;
					break;
				}
			}
			if (groupIsRelevant) {
				relevantMatchGroups.push(group);
			}
		});
	}
	if (relevantMatchGroups.length === 0) {
		// No new matches found in this pass.
		// If this is part of a cascade that just finished falling and found no new matches,
		// animateFallingCellsAndTriggerCascade's "no cells to shift" or "onFinish" paths
		// would have handled cleanup and this recursive call. So, simply returning is fine.
		return;
	}
	var cellsToMarkInThisPass = [];
	var uniqueCellTracker = {}; // To avoid processing a cell multiple times if in multiple groups
	relevantMatchGroups.forEach(function (group) {
		group.forEach(function (cell) {
			var cellKey = cell.row + "_" + cell.col;
			// Cell must exist in the grid logically (not already nullified by a previous step in the same destruction event)
			// and not yet tracked for this specific pass of marking.
			if (gridCells[cell.row] && gridCells[cell.row][cell.col] === cell && !uniqueCellTracker[cellKey]) {
				cellsToMarkInThisPass.push(cell);
				uniqueCellTracker[cellKey] = true;
			}
		});
	});
	if (cellsToMarkInThisPass.length > 0) {
		// These are newly identified cells to be destroyed (or marked for destruction)
		cellsToMarkInThisPass.forEach(function (cell) {
			// Add to global list for eventual physical destruction, if not already there from this destruction event
			if (!cellsPendingPhysicalDestruction.includes(cell)) {
				cellsPendingPhysicalDestruction.push(cell);
			}
			gridCells[cell.row][cell.col] = null; // Mark as empty in the logical grid
		});
		// Since new cells were marked (and thus logically removed from grid), trigger falling and subsequent checks
		animateFallingCellsAndTriggerCascade();
	} else if (relevantMatchGroups.length > 0 && cellsPendingPhysicalDestruction.length > 0) {
		// No *new* cells were marked in this pass (cellsToMarkInThisPass is empty),
		// BUT there were relevantMatchGroups (meaning matches exist, likely on already nulled spots)
		// AND there are cells pending physical destruction from previous steps of this same destruction event.
		// This implies we're in a complex cascade state. We should still trigger the falling/cleanup mechanism.
		animateFallingCellsAndTriggerCascade();
	}
	// If relevantMatchGroups.length > 0, but cellsToMarkInThisPass is 0, AND cellsPendingPhysicalDestruction is 0,
	// it implies a very specific state where matches are found on already nulled spots from a *fully completed previous destruction event*.
	// This case should be rare and ideally covered by the general flow. If it's problematic,
	// the condition `cellsPendingPhysicalDestruction.length > 0` in the else-if ensures we only proceed if there's an active destruction event.
}
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
@@ -50,8 +50,9 @@
 /**** 
 * Game Code
 ****/ 
 // Grid configuration
+var cellsPendingPhysicalDestruction = [];
 var selectedCell = null;
 function handleCellTap(tappedCell) {
 	if (selectedCell === null) {
 		selectedCell = tappedCell;
@@ -113,8 +114,21 @@
 			}
 		}
 	}
 }
+// Function to actually remove cells from display and destroy them
+function actuallyDestroyCells(arrayOfCells) {
+	arrayOfCells.forEach(function (cell) {
+		if (cell && cell.parent) {
+			// Check if cell exists and is still attached
+			gridContainer.removeChild(cell);
+		}
+		if (cell) {
+			// Check if cell exists before destroying
+			cell.destroy();
+		}
+	});
+}
 // Helper functions for match detection and destruction
 function getMatches() {
 	var matches = [];
 	var r, c, k, cell1, nextCell, currentMatchValue, currentMatchCells;
@@ -181,61 +195,151 @@
 		}
 	}
 	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 to animate falling cells and trigger further checks
+function animateFallingCellsAndTriggerCascade() {
+	var cellsToShiftVisualOnly = [];
+	var gridUpdates = []; // To store { cell, oldRow, oldCol, newRow, newCol }
+	for (var c = 0; c < gridSize; c++) {
+		// Iterate columns
+		var emptySlotsInColumn = 0;
+		for (var r = gridSize - 1; r >= 0; r--) {
+			// Iterate rows from bottom up
+			if (gridCells[r][c] === null) {
+				emptySlotsInColumn++;
+			} else if (emptySlotsInColumn > 0) {
+				var cellToMove = gridCells[r][c];
+				var newLogicalRow = r + emptySlotsInColumn;
+				var targetY = startY + newLogicalRow * (cellSize + cellSpacing);
+				cellsToShiftVisualOnly.push({
+					cell: cellToMove,
+					targetY: targetY
+				});
+				// Store details needed to update the logical grid
+				gridUpdates.push({
+					cell: cellToMove,
+					oldRow: r,
+					oldCol: c,
+					newRow: newLogicalRow,
+					newCol: c
+				});
+			}
 		}
+	}
+	// Apply logical grid updates *before* animation starts
+	// First, clear old positions of moving cells to avoid overwriting during update
+	gridUpdates.forEach(function (op) {
+		gridCells[op.oldRow][op.oldCol] = null;
 	});
+	// Then, place cells in their new logical positions and update their row property
+	gridUpdates.forEach(function (op) {
+		op.cell.row = op.newRow; // Update cell's internal knowledge of its row
+		gridCells[op.newRow][op.newCol] = op.cell;
+	});
+	if (cellsToShiftVisualOnly.length === 0) {
+		// No cells are moving, meaning falling is complete for this cascade step, or no fall was needed.
+		if (cellsPendingPhysicalDestruction.length > 0) {
+			actuallyDestroyCells(cellsPendingPhysicalDestruction);
+			cellsPendingPhysicalDestruction = []; // Clear the list
+		}
+		// Check for new matches on the entire board.
+		// Use LK.setTimeout to ensure this check happens after current execution context unwinds.
+		LK.setTimeout(function () {
+			checkForAndDestroyMatches(null, null); // Check entire board for new matches
+		}, 50); // A small delay
+		return;
+	}
+	var animationsInProgressCount = cellsToShiftVisualOnly.length;
+	cellsToShiftVisualOnly.forEach(function (shiftOp) {
+		tween(shiftOp.cell, {
+			y: shiftOp.targetY
+		}, {
+			duration: 300,
+			// Animation duration
+			easing: tween.easeOut,
+			// A smooth easing for falling
+			onFinish: function onFinish() {
+				animationsInProgressCount--;
+				if (animationsInProgressCount === 0) {
+					// All falling animations for this step are done
+					if (cellsPendingPhysicalDestruction.length > 0) {
+						actuallyDestroyCells(cellsPendingPhysicalDestruction);
+						cellsPendingPhysicalDestruction = []; // Clear the list
+					}
+					// Now, check for new matches formed by the fallen cells
+					LK.setTimeout(function () {
+						checkForAndDestroyMatches(null, null); // Recursive call for cascades
+					}, 50); // A small delay
+				}
+			}
+		});
+	});
 }
 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 allMatchGroupsOnBoard = getMatches();
 	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 (swappedCellA === null && swappedCellB === null) {
+		// Full board check for cascades
+		relevantMatchGroups = allMatchGroupsOnBoard;
+	} else {
+		// Initial check after a swap
+		allMatchGroupsOnBoard.forEach(function (group) {
+			var groupIsRelevant = false;
+			for (var i = 0; i < group.length; i++) {
+				var cellInGroup = group[i];
+				if (cellInGroup === swappedCellA || cellInGroup === swappedCellB) {
+					groupIsRelevant = true;
+					break;
+				}
 			}
-		}
-		if (groupIsRelevant) {
-			relevantMatchGroups.push(group);
-		}
-	});
+			if (groupIsRelevant) {
+				relevantMatchGroups.push(group);
+			}
+		});
+	}
 	if (relevantMatchGroups.length === 0) {
-		return; // No matches involving the swapped cells were found
+		// No new matches found in this pass.
+		// If this is part of a cascade that just finished falling and found no new matches,
+		// animateFallingCellsAndTriggerCascade's "no cells to shift" or "onFinish" paths
+		// would have handled cleanup and this recursive call. So, simply returning is fine.
+		return;
 	}
-	// Proceed with destroying cells from the relevant match groups
-	var cellsToDestroy = [];
-	var uniqueCellTracker = {}; // To ensure each cell is added only once
+	var cellsToMarkInThisPass = [];
+	var uniqueCellTracker = {}; // To avoid processing a cell multiple times if in multiple groups
 	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);
+			// Cell must exist in the grid logically (not already nullified by a previous step in the same destruction event)
+			// and not yet tracked for this specific pass of marking.
+			if (gridCells[cell.row] && gridCells[cell.row][cell.col] === cell && !uniqueCellTracker[cellKey]) {
+				cellsToMarkInThisPass.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);
+	if (cellsToMarkInThisPass.length > 0) {
+		// These are newly identified cells to be destroyed (or marked for destruction)
+		cellsToMarkInThisPass.forEach(function (cell) {
+			// Add to global list for eventual physical destruction, if not already there from this destruction event
+			if (!cellsPendingPhysicalDestruction.includes(cell)) {
+				cellsPendingPhysicalDestruction.push(cell);
+			}
+			gridCells[cell.row][cell.col] = null; // Mark as empty in the logical grid
+		});
+		// Since new cells were marked (and thus logically removed from grid), trigger falling and subsequent checks
+		animateFallingCellsAndTriggerCascade();
+	} else if (relevantMatchGroups.length > 0 && cellsPendingPhysicalDestruction.length > 0) {
+		// No *new* cells were marked in this pass (cellsToMarkInThisPass is empty),
+		// BUT there were relevantMatchGroups (meaning matches exist, likely on already nulled spots)
+		// AND there are cells pending physical destruction from previous steps of this same destruction event.
+		// This implies we're in a complex cascade state. We should still trigger the falling/cleanup mechanism.
+		animateFallingCellsAndTriggerCascade();
 	}
+	// If relevantMatchGroups.length > 0, but cellsToMarkInThisPass is 0, AND cellsPendingPhysicalDestruction is 0,
+	// it implies a very specific state where matches are found on already nulled spots from a *fully completed previous destruction event*.
+	// This case should be rare and ideally covered by the general flow. If it's problematic,
+	// the condition `cellsPendingPhysicalDestruction.length > 0` in the else-if ensures we only proceed if there's an active destruction event.
 }
 var gridSize = 9;
 var cellSpacing = 10;
 var cellSize = 160; // Width/height of the cell background