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

/**** 
* Classes
****/ 
var GridCell = Container.expand(function () {
	var self = Container.call(this);
	// Method to initialize or reset a cell
	self.init = function () {
		// Create the background square for the cell if it doesn't exist
		if (!self.background) {
			self.background = self.attachAsset('cuadricula', {
				anchorX: 0.5,
				anchorY: 0.5
			});
		}
		// Initialize or reset properties
		self.value = 0;
		self.sprite = null;
		self.row = -1;
		self.col = -1;
		return self; // Enable chaining
	};
	// Method to set value and corresponding sprite
	self.setValue = function (newValue) {
		// Skip if same value
		if (self.value === newValue) {
			return;
		}
		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);
	};
	// Handle tap event
	self.down = function (x, y, obj) {
		handleCellTap(self);
	};
	// Add a pulsing effect to the selected meme
	self.pulseEffect = function (activate) {
		if (activate && self.sprite) {
			// Stop any existing pulse animation
			if (self.pulseAnimation) {
				self.pulseAnimation.stop();
			}
			// Add a dark tint to the sprite
			self.sprite.tint = 0x777777;
			// Create a pulsing animation
			self.pulseAnimation = tween(self.sprite, {
				scale: 1.15
			}, {
				duration: 500,
				easing: tween.easeInOutSine,
				repeat: -1,
				yoyo: true
			});
		} else if (self.sprite) {
			// Stop the pulse animation if active
			if (self.pulseAnimation) {
				self.pulseAnimation.stop();
				self.pulseAnimation = null;
			}
			// Reset the sprite
			self.sprite.tint = 0xFFFFFF;
			self.sprite.scale = 1;
		}
	};
	// Initialize the cell
	self.init();
	return self;
});

/**** 
* Initialize Game
****/ 
// Factory function to get a GridCell (from pool or new)
// Grid configuration
var game = new LK.Game({
	backgroundColor: 0xF4FFFF
});

/**** 
* Game Code
****/ 
// Grid configuration
// Cell pool for object reuse
var cellPool = [];
// Factory function to get a GridCell (from pool or new)
function getGridCell() {
	if (cellPool.length > 0) {
		return cellPool.pop().init(); // Reuse a cell from the pool
	}
	return new GridCell(); // Create a new cell
}
// Function to return a cell to the pool
function recycleGridCell(cell) {
	if (cell) {
		cellPool.push(cell); // Add to pool for later reuse
	}
}
var selectedCell = null;
var isAnimating = false;
// Additional animation flags to prevent race conditions
window.gravityInProgress = false;
window.fillInProgress = false;
window.destructionInProgress = false;
window.pendingDestructions = [];
function handleCellTap(tappedCell) {
	// Check all animation flags to ensure no animations are in progress
	if (isAnimating || window.gravityInProgress || window.fillInProgress || window.destructionInProgress) {
		return;
	}
	if (selectedCell === null) {
		selectedCell = tappedCell;
		// Add pulse effect to the selected cell
		selectedCell.pulseEffect(true);
		return;
	}
	var cell1 = selectedCell;
	var cell2 = tappedCell;
	if (cell1 === cell2) {
		// Remove pulse effect and deselect
		cell1.pulseEffect(false);
		selectedCell = null;
		return;
	}
	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) {
		// Remove pulse effect from current selected cell
		cell1.pulseEffect(false);
		// Select and apply pulse effect to the new cell
		selectedCell = tappedCell;
		selectedCell.pulseEffect(true);
		return;
	}
	// Case 5: Adjacent cell - perform the swap
	// 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;
	// Remove pulse effect from selected cell
	cell1.pulseEffect(false);
	// 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
}
// Helper functions for match detection and destruction
function getMatches() {
	var matches = [];
	// Helper function to find matches in a specific direction
	function findDirectionalMatches(isHorizontal) {
		var primary, secondary;
		var primaryMax = isHorizontal ? gridSize + extraRows : gridSize;
		var secondaryMax = isHorizontal ? gridSize : gridSize + extraRows;
		// Only check visible grid plus extra rows above
		for (primary = isHorizontal ? extraRows : 0; primary < primaryMax; primary++) {
			for (secondary = 0; secondary < secondaryMax;) {
				// Skip if not enough cells left for a match of 3
				if (secondary > secondaryMax - 3) {
					secondary++;
					continue;
				}
				// Get current cell based on direction
				var cell1 = isHorizontal ? gridCells[primary][secondary] : gridCells[secondary][primary];
				if (!cell1) {
					// Skip empty cells
					secondary++;
					continue;
				}
				var currentMatchValue = cell1.value;
				var currentMatchCells = [cell1];
				// Check subsequent cells for matches
				for (var k = secondary + 1; k < secondaryMax; k++) {
					var nextCell = isHorizontal ? gridCells[primary][k] : gridCells[k][primary];
					if (nextCell && nextCell.value === currentMatchValue) {
						currentMatchCells.push(nextCell);
					} else {
						break; // End of current potential match
					}
				}
				// Add to matches if we found 3 or more
				if (currentMatchCells.length >= 3) {
					matches.push(currentMatchCells);
				}
				// Move index forward based on match length
				secondary += currentMatchCells.length > 0 ? currentMatchCells.length : 1;
			}
		}
	}
	// Find horizontal matches
	findDirectionalMatches(true);
	// Find vertical matches
	findDirectionalMatches(false);
	return matches;
}
function destroyCells(cellsToDestroy) {
	// Set animation flag to prevent user interaction during destruction
	isAnimating = true;
	// Check if we're already processing destruction
	if (window.destructionInProgress) {
		// Queue this destruction for later instead of running now
		if (!window.pendingDestructions) {
			window.pendingDestructions = [];
		}
		window.pendingDestructions.push(cellsToDestroy);
		return;
	}
	window.destructionInProgress = true;
	// Process each cell with a slight delay for more satisfying destruction
	var delay = 0;
	var delayIncrement = 100; // 100ms delay between each meme destruction
	// Calculate total destruction time for this sequence only
	var totalDestructionTime = cellsToDestroy.length * delayIncrement;
	cellsToDestroy.forEach(function (cell) {
		// Schedule destruction with increasing delay
		LK.setTimeout(function () {
			// 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) {
				// Play explosion sound
				LK.getSound('Explosion').play();
				// Visual flash effect
				LK.effects.flashObject(cell, 0xFFFFFF, 200);
				// Remove from display
				gridContainer.removeChild(cell);
				cell.destroy(); // Destroy the cell object (releases resources)
				gridCells[cell.row][cell.col] = null; // Mark as empty in the logical grid
			}
		}, delay);
		// Increase delay for next cell
		delay += delayIncrement;
	});
	// After destroying cells, make memes fall to fill empty spaces
	// Wait until all cells are destroyed using the exact time for this sequence
	LK.setTimeout(function () {
		window.destructionInProgress = false;
		// Check for pending destructions before applying gravity
		if (window.pendingDestructions && window.pendingDestructions.length > 0) {
			var nextDestructions = window.pendingDestructions.shift();
			LK.setTimeout(function () {
				destroyCells(nextDestructions);
			}, 50);
			return;
		}
		applyGravity();
	}, totalDestructionTime + 50); // Use exact time based on this destruction sequence
}
// Function to make memes fall down to fill empty spaces
function applyGravity() {
	// Set animation flag to prevent user interaction
	isAnimating = true;
	// Track all cells that need to fall for sequencing
	var cellsToFall = [];
	// Track if we're already processing gravity to prevent multiple calls
	if (window.gravityInProgress) {
		return;
	}
	window.gravityInProgress = true;
	// First pass: identify all cells that need to fall
	for (var col = 0; col < gridSize; col++) {
		// Start from the bottom row and work upwards
		for (var row = gridSize + extraRows - 1; row >= extraRows; row--) {
			// If current cell is empty
			if (!gridCells[row][col]) {
				// Look for the nearest non-empty cell above
				var sourceRow = row - 1;
				while (sourceRow >= 0 && !gridCells[sourceRow][col]) {
					sourceRow--;
				}
				// If we found a cell to move down
				if (sourceRow >= 0) {
					var cellToMove = gridCells[sourceRow][col];
					// Store the cell along with destination info
					cellsToFall.push({
						cell: cellToMove,
						fromRow: sourceRow,
						toRow: row,
						col: col
					});
					// Update grid array
					gridCells[row][col] = cellToMove;
					gridCells[sourceRow][col] = null;
					// Update cell's logical position
					cellToMove.row = row;
					// Add the cell to the grid container if it was previously hidden
					if (sourceRow < extraRows) {
						gridContainer.addChild(cellToMove);
					}
				}
			}
		}
	}
	// Second pass: animate falls with sequential delays
	var longestDelay = 0;
	var baseDelay = 30; // Base delay in ms between each meme starting to fall
	var constantDuration = 400; // Constant duration for all fall animations regardless of distance
	// Sort by column and row to make the animation more coherent
	cellsToFall.sort(function (a, b) {
		// Sort by column first
		if (a.col !== b.col) {
			return a.col - b.col;
		}
		// Then by destination row (lower row falls first) - this makes the animation go from bottom to top
		return b.toRow - a.toRow;
	});
	// Apply animations with sequential delays
	cellsToFall.forEach(function (fallInfo, index) {
		var delay = index * baseDelay; // Each meme starts falling after the previous one
		// Calculate destination position
		var newPos = getCellPosition(fallInfo.toRow, fallInfo.col);
		// Track the longest delay + duration for later use
		var totalTime = delay + constantDuration;
		if (totalTime > longestDelay) {
			longestDelay = totalTime;
		}
		// Schedule the animation with proper delay
		LK.setTimeout(function () {
			// Linear falling animation without bounce
			tween(fallInfo.cell, {
				y: newPos.y
			}, {
				duration: constantDuration,
				easing: tween.linear
			});
		}, delay);
	});
	// After all cells have fallen, fill in empty spaces at the top with new memes
	// Use the actual total animation time rather than a fixed value
	LK.setTimeout(function () {
		window.gravityInProgress = false;
		fillEmptySpacesWithNewMemes();
	}, longestDelay + 50); // Add a small buffer to ensure all falls are complete
}
// Create new memes to fill empty spots at the top of the grid
function fillEmptySpacesWithNewMemes() {
	// Check if we're already processing fill operation
	if (window.fillInProgress) {
		return;
	}
	window.fillInProgress = true;
	var anyNewMemeAdded = false;
	// Collect all new cells to add for sequenced animation
	var newCellsToAdd = [];
	// Check each column for empty spaces
	for (var col = 0; col < gridSize; col++) {
		// Start from the top (row 0) and fill any empty spaces
		for (var row = 0; row < gridSize + extraRows; row++) {
			if (!gridCells[row][col]) {
				anyNewMemeAdded = true;
				// Create a new meme cell
				var newCell = getGridCell();
				var pos = getCellPosition(row, col);
				// Position the new cell above the grid (for animation)
				newCell.x = pos.x;
				newCell.y = pos.y - 400; // Start above the visible grid
				// Set random value for the new meme
				var randomValue = Math.floor(Math.random() * 5) + 1;
				newCell.setValue(randomValue);
				// Set logical position
				newCell.row = row;
				newCell.col = col;
				// Add to grid array
				gridCells[row][col] = newCell;
				// Store cell data for animation
				newCellsToAdd.push({
					cell: newCell,
					destY: pos.y,
					row: row,
					col: col
				});
				// Only add to display if in visible area
				if (row >= extraRows) {
					gridContainer.addChild(newCell);
				}
			}
		}
	}
	// Animate cell drops with sequential delays
	var longestDelay = 0;
	var baseDelay = 30; // Delay between each meme starting to fall
	var constantDuration = 400; // Constant duration for all fall animations regardless of distance
	// Sort by column first, then by row for coherent animation - bottom to top
	newCellsToAdd.sort(function (a, b) {
		if (a.col !== b.col) {
			return a.col - b.col;
		}
		return b.row - a.row; // Higher rows (lower in grid) fall first - bottom to top animation
	});
	// Apply animations with sequential delays
	newCellsToAdd.forEach(function (cellData, index) {
		var delay = index * baseDelay;
		// Track total animation time
		var totalTime = delay + constantDuration;
		if (totalTime > longestDelay) {
			longestDelay = totalTime;
		}
		// Schedule the animation with proper delay
		LK.setTimeout(function () {
			// Linear falling with no bounce
			tween(cellData.cell, {
				y: cellData.destY
			}, {
				duration: constantDuration,
				easing: tween.linear
			});
		}, delay);
	});
	// If new memes were added, check for matches only after all fall animations are complete
	if (anyNewMemeAdded) {
		LK.setTimeout(function () {
			// Reset fill flag when animations are done
			window.fillInProgress = false;
			// Now that all falling animations are complete, check for matches
			var newMatches = getMatches();
			if (newMatches.length > 0) {
				// Get all cells from all new match groups
				var newCellsToDestroy = [];
				var newCellTracker = {};
				newMatches.forEach(function (group) {
					group.forEach(function (cell) {
						var cellKey = cell.row + "_" + cell.col;
						if (!newCellTracker[cellKey]) {
							newCellsToDestroy.push(cell);
							newCellTracker[cellKey] = true;
						}
					});
				});
				// Destroy these new matches only after all falling has fully completed
				if (newCellsToDestroy.length) {
					destroyCells(newCellsToDestroy);
				}
			} else {
				// No more matches, animations are complete, allow user interaction again
				isAnimating = false;
			}
		}, longestDelay + 50); // Use actual animation time plus buffer
	} else {
		// No new memes were added, animations are complete, allow user interaction again
		window.fillInProgress = false;
		isAnimating = false;
	}
}
function checkForAndDestroyMatches(swappedCellA, swappedCellB) {
	// Get all potential matches on the board
	var allMatchGroupsOnBoard = getMatches();
	// Quick return if no matches
	if (!allMatchGroupsOnBoard.length) {
		return; // No matches found anywhere, nothing to do
	}
	// Filter to only match groups containing one of the swapped cells
	var relevantMatchGroups = allMatchGroupsOnBoard.filter(function (group) {
		// Check if any cell in the group is one of our swapped cells
		return group.some(function (cellInGroup) {
			return cellInGroup === swappedCellA || cellInGroup === swappedCellB;
		});
	});
	if (!relevantMatchGroups.length) {
		return;
	}
	var uniqueCellTracker = {};
	var cellsToDestroy = [];
	relevantMatchGroups.forEach(function (group) {
		group.forEach(function (cell) {
			var cellKey = cell.row + "_" + cell.col;
			if (!uniqueCellTracker[cellKey]) {
				cellsToDestroy.push(cell);
				uniqueCellTracker[cellKey] = true;
			}
		});
	});
	if (cellsToDestroy.length) {
		destroyCells(cellsToDestroy);
		LK.setTimeout(function () {
			var newMatches = getMatches();
			if (newMatches.length > 0) {
				var newCellsToDestroy = [];
				var newCellTracker = {};
				newMatches.forEach(function (group) {
					group.forEach(function (cell) {
						var cellKey = cell.row + "_" + cell.col;
						if (!newCellTracker[cellKey]) {
							newCellsToDestroy.push(cell);
							newCellTracker[cellKey] = true;
						}
					});
				});
				if (newCellsToDestroy.length) {
					destroyCells(newCellsToDestroy);
				}
			}
		}, 400);
	}
}
var gridSize = 8;
var extraRows = 9;
var cellSpacing = 10;
var cellSize = 208;
var gridCells = [];
var totalGridWidth = gridSize * cellSize + (gridSize - 1) * cellSpacing;
var totalVisibleGridHeight = totalGridWidth;
var totalGridHeight = totalVisibleGridHeight + extraRows * (cellSize + cellSpacing);
var startX = (2048 - totalGridWidth) / 2 + cellSize / 2;
var startY = (-1300 - totalVisibleGridHeight) / 2 + cellSize / 2 + extraRows * (cellSize + cellSpacing);
function getCellPosition(row, col) {
	return {
		x: startX + col * (cellSize + cellSpacing),
		y: startY + row * (cellSize + cellSpacing) - extraRows * (cellSize + cellSpacing)
	};
}
var gridContainer = new Container();
game.addChild(gridContainer);
function initializeGrid() {
	gridCells = [];
	for (var row = 0; row < gridSize + extraRows; row++) {
		gridCells[row] = [];
		for (var col = 0; col < gridSize; col++) {
			var pos = getCellPosition(row, col);
			var cell = getGridCell ? getGridCell() : new GridCell();
			cell.x = pos.x;
			cell.y = pos.y;
			cell.row = row;
			cell.col = col;
			var randomValue;
			var attempts = 0;
			do {
				randomValue = Math.floor(Math.random() * 5) + 1;
				attempts++;
				var leftMatchCount = 0;
				var aboveMatchCount = 0;
				if (col >= 2) {
					if (gridCells[row][col - 1].value === randomValue && gridCells[row][col - 2].value === randomValue) {
						leftMatchCount = 2;
					}
				}
				if (row >= 2) {
					if (gridCells[row - 1][col].value === randomValue && gridCells[row - 2][col].value === randomValue) {
						aboveMatchCount = 2;
					}
				}
			} while ((leftMatchCount >= 2 || aboveMatchCount >= 2) && attempts < 10);
			cell.setValue(randomValue);
			if (row >= extraRows) {
				gridContainer.addChild(cell);
			}
			gridCells[row][col] = cell;
		}
	}
}
initializeGrid();
function ensureNoInitialMatches() {
	var matches = getMatches();
	if (matches.length > 0) {
		matches.forEach(function (group) {
			group.forEach(function (cell) {
				var currentValue = cell.value;
				var newValue;
				do {
					newValue = Math.floor(Math.random() * 5) + 1;
				} while (newValue === currentValue);
				cell.setValue(newValue);
			});
		});
		ensureNoInitialMatches();
	}
}
ensureNoInitialMatches();

===================================================================
--- original.js
+++ change.js
@@ -46,8 +46,37 @@
 	// Handle tap event
 	self.down = function (x, y, obj) {
 		handleCellTap(self);
 	};
+	// Add a pulsing effect to the selected meme
+	self.pulseEffect = function (activate) {
+		if (activate && self.sprite) {
+			// Stop any existing pulse animation
+			if (self.pulseAnimation) {
+				self.pulseAnimation.stop();
+			}
+			// Add a dark tint to the sprite
+			self.sprite.tint = 0x777777;
+			// Create a pulsing animation
+			self.pulseAnimation = tween(self.sprite, {
+				scale: 1.15
+			}, {
+				duration: 500,
+				easing: tween.easeInOutSine,
+				repeat: -1,
+				yoyo: true
+			});
+		} else if (self.sprite) {
+			// Stop the pulse animation if active
+			if (self.pulseAnimation) {
+				self.pulseAnimation.stop();
+				self.pulseAnimation = null;
+			}
+			// Reset the sprite
+			self.sprite.tint = 0xFFFFFF;
+			self.sprite.scale = 1;
+		}
+	};
 	// Initialize the cell
 	self.init();
 	return self;
 });
@@ -63,10 +92,10 @@
 
 /**** 
 * Game Code
 ****/ 
-// Cell pool for object reuse
 // Grid configuration
+// Cell pool for object reuse
 var cellPool = [];
 // Factory function to get a GridCell (from pool or new)
 function getGridCell() {
 	if (cellPool.length > 0) {
@@ -92,148 +121,73 @@
 	if (isAnimating || window.gravityInProgress || window.fillInProgress || window.destructionInProgress) {
 		return;
 	}
 	if (selectedCell === null) {
-		// Apply dark tint to the selected cell
-		tappedCell.sprite.tint = 0x666666;
-		// Create pulse effect
-		var pulseSequence = function pulseSequence() {
-			tween(tappedCell.sprite.scale, {
-				x: 1.2,
-				y: 1.2
-			}, {
-				duration: 300,
-				easing: tween.easeOutQuad,
-				onComplete: function onComplete() {
-					tween(tappedCell.sprite.scale, {
-						x: 1.0,
-						y: 1.0
-					}, {
-						duration: 300,
-						easing: tween.easeInQuad
-					});
-				}
-			});
-		};
-		// Start pulse animation
-		pulseSequence();
-		// Initiate pulse animation loop
-		var pulseInterval = LK.setInterval(pulseSequence, 700);
-		// Store the pulse interval on the cell for later cleanup
-		tappedCell.pulseInterval = pulseInterval;
-		// Set the selected cell with a slight delay
-		LK.setTimeout(function () {
-			selectedCell = tappedCell;
-		}, 200);
+		selectedCell = tappedCell;
+		// Add pulse effect to the selected cell
+		selectedCell.pulseEffect(true);
 		return;
 	}
 	var cell1 = selectedCell;
 	var cell2 = tappedCell;
 	if (cell1 === cell2) {
-		// Reset tint and clear pulse animation
-		if (cell1.pulseInterval) {
-			LK.clearInterval(cell1.pulseInterval);
-			cell1.pulseInterval = null;
-		}
-		cell1.sprite.tint = 0xFFFFFF;
-		cell1.sprite.scale.x = 1.0;
-		cell1.sprite.scale.y = 1.0;
+		// Remove pulse effect and deselect
+		cell1.pulseEffect(false);
 		selectedCell = null;
 		return;
 	}
 	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) {
-		// Reset tint and clear pulse animation on previous selection
-		if (cell1.pulseInterval) {
-			LK.clearInterval(cell1.pulseInterval);
-			cell1.pulseInterval = null;
-		}
-		cell1.sprite.tint = 0xFFFFFF;
-		cell1.sprite.scale.x = 1.0;
-		cell1.sprite.scale.y = 1.0;
-		// Apply effects to new selection with delay
-		tappedCell.sprite.tint = 0x666666;
-		// Create pulse effect for new selection
-		var pulseSequence = function pulseSequence() {
-			tween(tappedCell.sprite.scale, {
-				x: 1.2,
-				y: 1.2
-			}, {
-				duration: 300,
-				easing: tween.easeOutQuad,
-				onComplete: function onComplete() {
-					tween(tappedCell.sprite.scale, {
-						x: 1.0,
-						y: 1.0
-					}, {
-						duration: 300,
-						easing: tween.easeInQuad
-					});
-				}
-			});
-		};
-		// Start pulse animation
-		pulseSequence();
-		// Initiate pulse animation loop
-		var pulseInterval = LK.setInterval(pulseSequence, 700);
-		// Store the pulse interval on the cell for later cleanup
-		tappedCell.pulseInterval = pulseInterval;
+		// Remove pulse effect from current selected cell
+		cell1.pulseEffect(false);
+		// Select and apply pulse effect to the new cell
 		selectedCell = tappedCell;
+		selectedCell.pulseEffect(true);
 		return;
 	}
 	// Case 5: Adjacent cell - perform the swap
-	// Reset tint and clear pulse animation before swap
-	if (cell1.pulseInterval) {
-		LK.clearInterval(cell1.pulseInterval);
-		cell1.pulseInterval = null;
-	}
-	cell1.sprite.tint = 0xFFFFFF;
-	cell1.sprite.scale.x = 1.0;
-	cell1.sprite.scale.y = 1.0;
-	// Delay the swap execution
-	isAnimating = true;
+	// 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;
+	// Remove pulse effect from selected cell
+	cell1.pulseEffect(false);
+	// 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 () {
-		// 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
-	}, 300); // Delay the swap execution by 300ms
+		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
 }
 // Helper functions for match detection and destruction
 function getMatches() {
 	var matches = [];