===================================================================
--- original.js
+++ change.js
@@ -7,108 +7,137 @@
 * Classes
 ****/ 
 var GridCell = Container.expand(function () {
 	var self = Container.call(this);
+	// Define the special cell tint colors as constants
+	var BOMB_TINT = 0x0088FF;
+	var GREEN_TINT = 0x00FF00;
+	var LINE_TINT = 0xFF8800;
+	var SELECTION_TINT = 0x00FFFF;
+	// Initialize method with improved structure
 	self.init = function () {
+		// Create background only if it doesn't exist
 		if (!self.background) {
 			self.background = self.attachAsset('cuadricula', {
 				anchorX: 0.5,
 				anchorY: 0.5
 			});
 		}
+		// Reset all properties to default values
 		self.value = 0;
 		self.sprite = null;
 		self.row = -1;
 		self.col = -1;
 		self.isSpecial = false;
 		self.specialType = null;
+		self.beingDestroyed = false;
+		self.lastIntersecting = false;
 		return self;
 	};
+	// Set value with improved appearance handling
 	self.setValue = function (newValue) {
+		// Skip if value hasn't changed
 		if (self.value === newValue) {
 			return;
 		}
+		// Update value
 		self.value = newValue;
+		// Remove existing sprite
 		if (self.sprite) {
 			self.removeChild(self.sprite);
 		}
+		// Create new sprite
 		var spriteId = 'meme' + newValue;
 		self.sprite = LK.getAsset(spriteId, {
 			anchorX: 0.5,
 			anchorY: 0.5
 		});
 		self.addChild(self.sprite);
-		self.updateSpecialAppearance();
+		// Apply special effects if needed
+		self.updateAppearance();
 	};
-	self.updateSpecialAppearance = function () {
-		if (self.isSpecial && self.sprite) {
+	// New helper method to update appearance based on special state
+	self.updateAppearance = function () {
+		if (!self.sprite) return;
+		// Reset tint first
+		self.sprite.tint = 0xFFFFFF;
+		// Apply special tint if needed
+		if (self.isSpecial) {
 			if (self.specialType === 'bomb') {
-				self.sprite.tint = 0x0088FF;
+				self.sprite.tint = BOMB_TINT;
 			} else if (self.specialType === 'green') {
-				self.sprite.tint = 0x00FF00;
+				self.sprite.tint = GREEN_TINT;
 			} else {
-				self.sprite.tint = 0xFF8800;
+				self.sprite.tint = LINE_TINT;
 			}
 		}
 	};
+	// Activate special power with improved efficiency
 	self.activateSpecialPower = function () {
 		if (!self.isSpecial) {
 			return;
 		}
 		var cellsToDestroy = [];
+		// Collect cells based on special type
 		if (self.specialType === 'horizontal') {
+			// Destroy all cells in the same row
 			for (var row = extraRows; row < gridSize + extraRows; row++) {
 				if (gridCells[row][self.col] && gridCells[row][self.col] !== self) {
 					cellsToDestroy.push(gridCells[row][self.col]);
 				}
 			}
 		} else if (self.specialType === 'vertical') {
+			// Destroy all cells in the same column
 			for (var col = 0; col < gridSize; col++) {
 				if (gridCells[self.row][col] && gridCells[self.row][col] !== self) {
 					cellsToDestroy.push(gridCells[self.row][col]);
 				}
 			}
 		} else if (self.specialType === 'bomb') {
-			for (var row = Math.max(extraRows, self.row - 1); row <= Math.min(gridSize + extraRows - 1, self.row + 1); row++) {
-				for (var col = Math.max(0, self.col - 1); col <= Math.min(gridSize - 1, self.col + 1); col++) {
+			// Destroy cells in a 3x3 area
+			var minRow = Math.max(extraRows, self.row - 1);
+			var maxRow = Math.min(gridSize + extraRows - 1, self.row + 1);
+			var minCol = Math.max(0, self.col - 1);
+			var maxCol = Math.min(gridSize - 1, self.col + 1);
+			for (var row = minRow; row <= maxRow; row++) {
+				for (var col = minCol; col <= maxCol; col++) {
 					if (gridCells[row][col] && gridCells[row][col] !== self) {
 						cellsToDestroy.push(gridCells[row][col]);
 					}
 				}
 			}
-		} else if (self.specialType === 'green') {}
+		} else if (self.specialType === 'green') {
+			// Green special power is handled elsewhere
+		}
+		// Process destruction if we have cells to destroy
 		if (cellsToDestroy.length > 0) {
 			destroyCells(cellsToDestroy);
 			self.beingDestroyed = true;
 			LK.getSound('Explosion').play();
 			LK.effects.flashObject(self, 0xFFFFFF, 200);
 			gridContainer.removeChild(self);
 			self.destroy();
 			gridCells[self.row][self.col] = null;
-			// Ensure gravity is triggered after special power is used
-			LK.setTimeout(function () {
-				if (!window.gravityInProgress && !window.fillInProgress) {
-					window.destructionInProgress = false;
-					applyGravity();
-				}
-			}, 300);
 		}
 	};
+	// Show selection with improved animation
 	self.showSelection = function () {
 		if (self.selectionHighlight) {
 			return;
 		}
+		// Create selection container
 		self.selectionHighlight = new Container();
 		var highlight = LK.getAsset('cuadricula', {
 			anchorX: 0.5,
 			anchorY: 0.5,
 			scaleX: 1.15,
 			scaleY: 1.15,
 			alpha: 0.6
 		});
-		highlight.tint = 0x00FFFF;
+		highlight.tint = SELECTION_TINT;
 		self.selectionHighlight.addChild(highlight);
 		self.addChildAt(self.selectionHighlight, 0);
+		// Define pulse animation
 		function pulseAnimation() {
 			tween(highlight, {
 				alpha: 0.3,
 				scaleX: 1.2,
@@ -128,19 +157,23 @@
 					});
 				}
 			});
 		}
+		// Start animation
 		pulseAnimation();
 	};
+	// Hide selection with efficient cleanup
 	self.hideSelection = function () {
 		if (self.selectionHighlight) {
 			self.removeChild(self.selectionHighlight);
 			self.selectionHighlight = null;
 		}
 	};
+	// Handle tap/click events
 	self.down = function (x, y, obj) {
 		handleCellTap(self);
 	};
+	// Initialize on creation
 	self.init();
 	return self;
 });
 
@@ -169,71 +202,74 @@
 var selectedCell = null;
 var isAnimating = false;
 window.gravityInProgress = false;
 window.fillInProgress = false;
-window.destructionInProgress = false;
 var comboCounter = 0;
 var comboInProgress = false;
-function isValidCell(cell) {
-	return cell && gridCells[cell.row] && gridCells[cell.row][cell.col] === cell && !cell.beingDestroyed;
-}
 function handleCellTap(tappedCell) {
+	// Exit early if animations are in progress
 	if (isAnimating || window.gravityInProgress || window.fillInProgress) {
 		return;
 	}
-	if (!isValidCell(tappedCell)) {
+	// Validate tapped cell
+	if (!tappedCell || !gridCells[tappedCell.row] || gridCells[tappedCell.row][tappedCell.col] !== tappedCell || tappedCell.beingDestroyed) {
 		return;
 	}
-	if (selectedCell !== null) {
-		if (selectedCell && gridCells[selectedCell.row] && gridCells[selectedCell.row][selectedCell.col] === selectedCell) {
-			var areAdjacentCells = function areAdjacentCells(cell1, cell2) {
-				return Math.abs(cell1.row - cell2.row) === 1 && cell1.col === cell2.col || Math.abs(cell1.col - cell2.col) === 1 && cell1.row === cell2.row;
-			};
-			if (selectedCell === tappedCell) {
-				selectedCell.hideSelection();
-				selectedCell = null;
-				return;
-			}
-			if (!areAdjacentCells(selectedCell, tappedCell)) {
-				selectedCell.hideSelection();
-				selectedCell = tappedCell;
-				selectedCell.showSelection();
-				return;
-			}
-			var cell1 = selectedCell;
-			var cell2 = tappedCell;
-			cell1.hideSelection();
-			selectedCell = null;
-			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) {
-				return;
-			}
-		} else {
-			if (selectedCell) {
-				selectedCell.hideSelection();
-			}
-			selectedCell = tappedCell;
-			selectedCell.showSelection();
-			return;
+	// Handle first selection
+	if (selectedCell === null) {
+		selectedCell = tappedCell;
+		selectedCell.showSelection();
+		return;
+	}
+	// Validate selected cell still exists
+	if (!gridCells[selectedCell.row] || gridCells[selectedCell.row][selectedCell.col] !== selectedCell) {
+		// Selected cell no longer valid, use tapped cell instead
+		if (selectedCell) {
+			selectedCell.hideSelection();
 		}
-	} else {
 		selectedCell = tappedCell;
 		selectedCell.showSelection();
 		return;
 	}
+	// Handle tap on already selected cell (deselect)
+	if (selectedCell === tappedCell) {
+		selectedCell.hideSelection();
+		selectedCell = null;
+		return;
+	}
+	// Check if cells are adjacent
+	var isAdjacent = Math.abs(selectedCell.row - tappedCell.row) === 1 && selectedCell.col === tappedCell.col || Math.abs(selectedCell.col - tappedCell.col) === 1 && selectedCell.row === tappedCell.row;
+	// If not adjacent, select the new cell instead
+	if (!isAdjacent) {
+		selectedCell.hideSelection();
+		selectedCell = tappedCell;
+		selectedCell.showSelection();
+		return;
+	}
+	// Set up cell swap
+	var cell1 = selectedCell;
+	var cell2 = tappedCell;
+	// Clear selection
+	cell1.hideSelection();
+	selectedCell = null;
+	// Begin swap animation
 	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 grid positions
 	var row1 = cell1.row;
 	var col1 = cell1.col;
 	var row2 = cell2.row;
 	var col2 = cell2.col;
+	// Categorize special cell interactions
 	var greenSpecialCell = null;
 	var regularCell = null;
 	var lineSpecialCells = [];
 	var twoGreenSpecials = false;
+	// Check for green special interactions
 	if (cell1.isSpecial && cell1.specialType === 'green' && cell2.isSpecial && cell2.specialType === 'green') {
 		twoGreenSpecials = true;
 	} else if (cell1.isSpecial && cell1.specialType === 'green') {
 		greenSpecialCell = cell1;
@@ -241,20 +277,23 @@
 	} else if (cell2.isSpecial && cell2.specialType === 'green') {
 		greenSpecialCell = cell2;
 		regularCell = cell1;
 	}
+	// Check for line special interactions
 	if (cell1.isSpecial && (cell1.specialType === 'horizontal' || cell1.specialType === 'vertical')) {
 		lineSpecialCells.push(cell1);
 	}
 	if (cell2.isSpecial && (cell2.specialType === 'horizontal' || cell2.specialType === 'vertical')) {
 		lineSpecialCells.push(cell2);
 	}
+	// Update grid references
 	gridCells[row1][col1] = cell2;
 	gridCells[row2][col2] = cell1;
 	cell1.row = row2;
 	cell1.col = col2;
 	cell2.row = row1;
 	cell2.col = col1;
+	// Hide any remaining selection highlights
 	if (cell1.selectionHighlight) {
 		cell1.hideSelection();
 	}
 	if (cell2.selectionHighlight) {
@@ -498,203 +537,205 @@
 	}, 350);
 }
 function getMatches() {
 	var matches = [];
+	// Optimized function to find matches in either horizontal or vertical direction
 	function findDirectionalMatches(isHorizontal) {
-		var primary, secondary;
-		var primaryMax = isHorizontal ? gridSize + extraRows : gridSize;
-		var secondaryMax = isHorizontal ? gridSize : gridSize + extraRows;
-		for (primary = isHorizontal ? extraRows : 0; primary < primaryMax; primary++) {
-			if (!gridCells[primary]) {
+		var primaryCount = isHorizontal ? gridSize + extraRows : gridSize;
+		var secondaryCount = isHorizontal ? gridSize : gridSize + extraRows;
+		// Loop through primary dimension (rows or columns)
+		for (var primary = isHorizontal ? 0 : 0; primary < primaryCount; primary++) {
+			if (!gridCells[primary] && isHorizontal) {
 				continue;
 			}
-			for (secondary = 0; secondary < secondaryMax;) {
-				if (secondary > secondaryMax - 3) {
-					secondary++;
-					continue;
+			// Track current match sequence
+			var currentValue = -1;
+			var matchStart = 0;
+			var matchLength = 0;
+			// Scan through secondary dimension
+			for (var secondary = 0; secondary <= secondaryCount; secondary++) {
+				// Get current cell or null if beyond grid or at end of scan
+				var currentCell = null;
+				if (secondary < secondaryCount) {
+					currentCell = isHorizontal ? gridCells[primary] ? gridCells[primary][secondary] : null : gridCells[secondary] ? gridCells[secondary][primary] : null;
 				}
-				var cell1 = isHorizontal ? gridCells[primary] ? gridCells[primary][secondary] : null : gridCells[secondary] ? gridCells[secondary][primary] : null;
-				if (!cell1 || !cell1.value) {
-					secondary++;
-					continue;
-				}
-				var currentMatchValue = cell1.value;
-				var currentMatchCells = [cell1];
-				for (var k = secondary + 1; k < secondaryMax; k++) {
-					var nextCell = isHorizontal ? gridCells[primary] ? gridCells[primary][k] : null : gridCells[k] ? gridCells[k][primary] : null;
-					if (nextCell && nextCell.value === currentMatchValue) {
-						currentMatchCells.push(nextCell);
-					} else {
-						LK.setTimeout(function () {
-							if (!window.gravityInProgress && !window.fillInProgress) {
-								comboInProgress = false;
-								comboCounter = 0;
+				// Check if current cell continues the match
+				if (currentCell && currentCell.value && currentCell.value === currentValue) {
+					matchLength++;
+				} else {
+					// Process completed match if long enough
+					if (matchLength >= 3) {
+						var matchCells = [];
+						// Collect all cells in the match
+						for (var i = 0; i < matchLength; i++) {
+							var cell = isHorizontal ? gridCells[primary][matchStart + i] : gridCells[matchStart + i][primary];
+							if (cell && gridCells[cell.row] && gridCells[cell.row][cell.col] === cell) {
+								matchCells.push(cell);
 							}
-						}, 500);
-						break;
-					}
-				}
-				if (currentMatchCells.length >= 3) {
-					var validCells = currentMatchCells.filter(function (cell) {
-						return cell && gridCells[cell.row] && gridCells[cell.row][cell.col] === cell;
-					});
-					if (validCells.length >= 3) {
-						var visibleCells = validCells.filter(function (cell) {
-							return cell.row >= extraRows;
-						});
-						var invisibleCells = validCells.filter(function (cell) {
-							return cell.row < extraRows;
-						});
-						if (visibleCells.length === 0 || invisibleCells.length === 0 || visibleCells.length >= 3) {
-							validCells.isHorizontal = isHorizontal;
-							validCells.matchType = currentMatchValue;
-							matches.push(validCells);
 						}
+						// Only add valid matches with minimum length
+						if (matchCells.length >= 3) {
+							// Count visible and invisible cells
+							var visibleCount = 0;
+							var invisibleCount = 0;
+							for (var i = 0; i < matchCells.length; i++) {
+								if (matchCells[i].row >= extraRows) {
+									visibleCount++;
+								} else {
+									invisibleCount++;
+								}
+							}
+							// Add match if it satisfies visibility criteria
+							if (visibleCount === 0 || invisibleCount === 0 || visibleCount >= 3) {
+								matchCells.isHorizontal = isHorizontal;
+								matchCells.matchType = currentValue;
+								matches.push(matchCells);
+							}
+						}
 					}
+					// Start new potential match
+					if (currentCell && currentCell.value) {
+						currentValue = currentCell.value;
+						matchStart = secondary;
+						matchLength = 1;
+					} else {
+						currentValue = -1;
+						matchLength = 0;
+					}
 				}
-				secondary += currentMatchCells.length > 0 ? currentMatchCells.length : 1;
 			}
 		}
 	}
-	findDirectionalMatches(true);
-	findDirectionalMatches(false);
+	// Find matches in both directions
+	findDirectionalMatches(true); // Horizontal
+	findDirectionalMatches(false); // Vertical
 	return matches;
 }
 function destroyCells(cellsToDestroy) {
 	isAnimating = true;
-	window.destructionInProgress = true;
-	var destructionId = Date.now() + Math.random();
-	var visibleCells = cellsToDestroy.filter(function (cell) {
-		return cell.row >= extraRows;
-	});
-	var invisibleCells = cellsToDestroy.filter(function (cell) {
-		return cell.row < extraRows;
-	});
-	if (visibleCells.length > 0 && invisibleCells.length > 0 && (visibleCells.length === 1 || invisibleCells.length === 1)) {
+	// Partition cells into visible and valid cells in one pass
+	var visibleCellsToDestroy = [];
+	var invisibleCells = [];
+	var validCellMap = {};
+	for (var i = 0; i < cellsToDestroy.length; i++) {
+		var cell = cellsToDestroy[i];
+		if (!cell || !gridCells[cell.row] || gridCells[cell.row][cell.col] !== cell) continue;
+		if (cell.row >= extraRows) {
+			visibleCellsToDestroy.push(cell);
+			validCellMap[cell.row + "_" + cell.col] = cell;
+		} else {
+			invisibleCells.push(cell);
+		}
+	}
+	// Early exit if not enough visible or invisible cells
+	if (visibleCellsToDestroy.length > 0 && invisibleCells.length > 0 && (visibleCellsToDestroy.length === 1 || invisibleCells.length === 1)) {
 		isAnimating = false;
-		window.destructionInProgress = false;
 		return;
 	}
-	var visibleCellsToDestroy = cellsToDestroy.filter(function (cell) {
-		return cell.row >= extraRows && cell && gridCells[cell.row] && gridCells[cell.row][cell.col] === cell;
-	});
+	// Determine center cell
 	var centerCell = null;
 	if (arguments.length > 1 && arguments[1]) {
 		centerCell = arguments[1];
 	} else if (cellsToDestroy.length > 0) {
 		centerCell = cellsToDestroy[Math.floor(cellsToDestroy.length / 2)];
 	}
+	// Group cells by type efficiently
 	var cellsByType = {};
-	visibleCellsToDestroy.forEach(function (cell) {
+	for (var i = 0; i < visibleCellsToDestroy.length; i++) {
+		var cell = visibleCellsToDestroy[i];
 		if (!cellsByType[cell.value]) {
 			cellsByType[cell.value] = [];
 		}
 		cellsByType[cell.value].push(cell);
-	});
+	}
+	// Handle combo sound
 	var uniqueGroupCount = Object.keys(cellsByType).length;
 	if (uniqueGroupCount > 0) {
 		if (!comboInProgress) {
 			comboCounter = uniqueGroupCount;
 			comboInProgress = true;
 		} else {
 			comboCounter += uniqueGroupCount;
 		}
-		playComboSound(comboCounter);
-	}
-	function playComboSound(comboCount) {
-		// Stop all combo sounds
-		for (var i = 1; i <= 5; i++) {
-			LK.getSound('Combo' + i).stop();
-		}
-		// Play appropriate combo sound based on count
-		if (comboCount >= 9) {
+		// Stop all combo sounds before playing a new one
+		LK.getSound('Combo1').stop();
+		LK.getSound('Combo2').stop();
+		LK.getSound('Combo3').stop();
+		LK.getSound('Combo4').stop();
+		LK.getSound('Combo5').stop();
+		// Play the appropriate combo sound
+		if (comboCounter >= 9) {
 			LK.getSound('Combo5').play();
-		} else if (comboCount >= 6) {
+		} else if (comboCounter >= 6) {
 			LK.getSound('Combo4').play();
-		} else if (comboCount >= 4) {
+		} else if (comboCounter >= 4) {
 			LK.getSound('Combo3').play();
-		} else if (comboCount >= 3) {
+		} else if (comboCounter >= 3) {
 			LK.getSound('Combo2').play();
-		} else if (comboCount >= 2) {
+		} else if (comboCounter >= 2) {
 			LK.getSound('Combo1').play();
 		}
 	}
-	var specialCell = createSpecialCell(cellsByType, centerCell, visibleCellsToDestroy);
-	if (specialCell) {
-		visibleCellsToDestroy = visibleCellsToDestroy.filter(function (cell) {
-			return cell !== specialCell;
-		});
-	}
-	function createSpecialCell(cellsByType, centerCell, visibleCells) {
-		var specialCell = null;
-		for (var type in cellsByType) {
-			var typeCells = cellsByType[type];
-			var typeValue = parseInt(type);
-			// Handle matches of 6 or more - create green special
-			if (typeCells.length >= 6) {
-				specialCell = chooseSpecialCell(centerCell, typeCells, typeValue);
-				initializeSpecialCell(specialCell, 'green');
-				return specialCell;
+	// Process special cells
+	var specialCell = null;
+	for (var type in cellsByType) {
+		var typeCells = cellsByType[type];
+		var typeValue = parseInt(type);
+		// Handle special cell creation based on match length
+		if (typeCells.length >= 6) {
+			specialCell = centerCell && centerCell.value === typeValue ? centerCell : typeCells[0];
+			specialCell.isSpecial = true;
+			specialCell.specialType = 'green';
+			specialCell.beingDestroyed = false;
+			delete validCellMap[specialCell.row + "_" + specialCell.col];
+			break;
+		} else if (typeCells.length === 5) {
+			specialCell = centerCell && centerCell.value === typeValue ? centerCell : typeCells[0];
+			specialCell.isSpecial = true;
+			specialCell.specialType = 'bomb';
+			specialCell.beingDestroyed = false;
+			delete validCellMap[specialCell.row + "_" + specialCell.col];
+			break;
+		} else if (typeCells.length === 4) {
+			// Check if cells are in same row or column
+			var firstCell = typeCells[0];
+			var allInSameRow = true;
+			var allInSameCol = true;
+			for (var i = 1; i < typeCells.length; i++) {
+				if (typeCells[i].row !== firstCell.row) allInSameRow = false;
+				if (typeCells[i].col !== firstCell.col) allInSameCol = false;
 			}
-			// Handle matches of 5 - create bomb special
-			else if (typeCells.length === 5) {
-				specialCell = chooseSpecialCell(centerCell, typeCells, typeValue);
-				initializeSpecialCell(specialCell, 'bomb');
-				return specialCell;
+			if (allInSameRow || allInSameCol) {
+				specialCell = centerCell && centerCell.value === typeValue ? centerCell : typeCells[0];
+				specialCell.isSpecial = true;
+				specialCell.specialType = allInSameRow ? 'horizontal' : 'vertical';
+				specialCell.beingDestroyed = false;
+				delete validCellMap[specialCell.row + "_" + specialCell.col];
+				break;
 			}
-			// Handle matches of 4 - create horizontal/vertical special
-			else if (typeCells.length === 4) {
-				var firstCell = typeCells[0];
-				var isHorizontalMatch = true;
-				var isVerticalMatch = true;
-				for (var i = 1; i < typeCells.length; i++) {
-					if (typeCells[i].row !== firstCell.row) {
-						isHorizontalMatch = false;
-					}
-					if (typeCells[i].col !== firstCell.col) {
-						isVerticalMatch = false;
-					}
-				}
-				if (isHorizontalMatch || isVerticalMatch) {
-					specialCell = chooseSpecialCell(centerCell, typeCells, typeValue);
-					initializeSpecialCell(specialCell, isHorizontalMatch ? 'horizontal' : 'vertical');
-					return specialCell;
-				}
-			}
 		}
-		return null;
 	}
-	function chooseSpecialCell(centerCell, typeCells, typeValue) {
-		if (centerCell && centerCell.value === typeValue) {
-			return centerCell;
-		} else {
-			return typeCells[0];
-		}
-	}
-	function initializeSpecialCell(cell, specialType) {
-		cell.isSpecial = true;
-		cell.specialType = specialType;
-		cell.beingDestroyed = false;
-		cell.updateSpecialAppearance();
-	}
+	// Rebuild list of cells to destroy (excluding special cell)
+	visibleCellsToDestroy = Object.values(validCellMap);
+	// Sort cells by distance from center if needed
 	if (centerCell && visibleCellsToDestroy.length > 0) {
 		visibleCellsToDestroy.sort(function (a, b) {
 			var distA = Math.abs(a.row - centerCell.row) + Math.abs(a.col - centerCell.col);
 			var distB = Math.abs(b.row - centerCell.row) + Math.abs(b.col - centerCell.col);
 			return distA - distB;
 		});
 	}
-	var totalDestructionTime = 0;
-	visibleCellsToDestroy.forEach(function (cell) {
-		if (cell) {
-			cell.beingDestroyed = true;
-			if (cell.isSpecial) {
-				LK.setTimeout(function () {
-					cell.activateSpecialPower();
-				}, 100);
-			}
+	// Mark cells for destruction
+	for (var i = 0; i < visibleCellsToDestroy.length; i++) {
+		var cell = visibleCellsToDestroy[i];
+		cell.beingDestroyed = true;
+		if (cell.isSpecial) {
+			LK.setTimeout(function () {
+				cell.activateSpecialPower();
+			}, 100);
 		}
-	});
+	}
+	// Handle special cell appearance
 	if (specialCell && specialCell.isSpecial) {
 		if (specialCell.specialType === 'bomb') {
 			specialCell.sprite.tint = 0x0088FF;
 		} else if (specialCell.specialType === 'green') {
@@ -703,394 +744,324 @@
 			specialCell.sprite.tint = 0xFF8800;
 		}
 		LK.effects.flashObject(specialCell, 0xFFFFFF, 300);
 	}
-	destroyVisibleCells(visibleCellsToDestroy);
-	function destroyVisibleCells(cells) {
-		// Play sound once for all cells rather than for each cell
-		if (cells.length > 0) {
+	// Immediately destroy marked cells
+	for (var i = 0; i < visibleCellsToDestroy.length; i++) {
+		var cell = visibleCellsToDestroy[i];
+		if (cell && cell.beingDestroyed && gridCells[cell.row] && gridCells[cell.row][cell.col] === cell) {
 			LK.getSound('Explosion').play();
+			LK.effects.flashObject(cell, 0xFFFFFF, 200);
+			gridContainer.removeChild(cell);
+			cell.destroy();
+			gridCells[cell.row][cell.col] = null;
 		}
-		cells.forEach(function (cell) {
-			if (cell && cell.beingDestroyed && gridCells[cell.row] && gridCells[cell.row][cell.col] === cell) {
-				LK.effects.flashObject(cell, 0xFFFFFF, 200);
-				gridContainer.removeChild(cell);
-				cell.destroy();
-				gridCells[cell.row][cell.col] = null;
-			}
-		});
 	}
-	var allCellsDestroyed = true;
-	for (var r = 0; r < gridSize + extraRows; r++) {
-		for (var c = 0; c < gridSize; c++) {
-			if (gridCells[r] && gridCells[r][c] && gridCells[r][c].beingDestroyed) {
-				allCellsDestroyed = false;
-			}
-		}
-	}
-	if (allCellsDestroyed && !window.gravityInProgress && !window.fillInProgress) {
-		window.destructionInProgress = false;
-		applyGravity();
-	} else {
-		// Set a safety timer to ensure gravity is applied even if some cells remain in destruction state
-		LK.setTimeout(function () {
-			window.destructionInProgress = false;
-			if (!window.gravityInProgress && !window.fillInProgress) {
-				applyGravity();
-			}
-		}, 500);
-	}
+	// Apply gravity immediately after destruction
+	applyGravity();
 }
 function applyGravity() {
 	isAnimating = true;
-	var cellsToFall = [];
+	// Early return if gravity is already in progress
 	if (window.gravityInProgress) {
 		return;
 	}
 	window.gravityInProgress = true;
-	// Reset destructionInProgress to ensure gravity can continue
-	window.destructionInProgress = false;
-	// Scan grid and find cells that need to fall
-	processGridForGravity(cellsToFall);
-	// Animation constants
-	var baseDelay = 30;
-	var constantDuration = 400;
-	// Sort for consistent animation order
+	var cellsToFall = [];
+	// Find all cells that need to fall
+	for (var col = 0; col < gridSize; col++) {
+		var emptySpaces = [];
+		// First pass: identify empty spaces
+		for (var row = gridSize + extraRows - 1; row >= 0; row--) {
+			if (!gridCells[row] || !gridCells[row][col]) {
+				if (row >= extraRows) {
+					emptySpaces.push(row);
+				}
+			} else if (emptySpaces.length > 0 && gridCells[row][col]) {
+				// We have a cell that can fall into an empty space
+				var targetRow = emptySpaces.shift();
+				var cellToMove = gridCells[row][col];
+				cellsToFall.push({
+					cell: cellToMove,
+					fromRow: row,
+					toRow: targetRow,
+					col: col
+				});
+				// Update grid references
+				gridCells[targetRow][col] = cellToMove;
+				gridCells[row][col] = null;
+				cellToMove.row = targetRow;
+				// Add to visible container if coming from hidden area
+				if (row < extraRows && targetRow >= extraRows) {
+					gridContainer.addChild(cellToMove);
+				}
+				// Add the now-empty source row back to empty spaces
+				emptySpaces.push(row);
+				// Sort to maintain order
+				emptySpaces.sort(function (a, b) {
+					return b - a;
+				});
+			}
+		}
+	}
+	// Use a constant animation duration without incremental delays
+	var animationDuration = 300;
+	// Sort cells by column then by target row (bottom to top) for natural looking gravity
 	cellsToFall.sort(function (a, b) {
 		if (a.col !== b.col) {
 			return a.col - b.col;
 		}
 		return b.toRow - a.toRow;
 	});
-	// Start animations
-	var longestDelay = animateFallingCells(cellsToFall, baseDelay, constantDuration);
-	// Schedule next step
-	LK.setTimeout(function () {
+	// Start all animations immediately
+	for (var i = 0; i < cellsToFall.length; i++) {
+		var fallInfo = cellsToFall[i];
+		var newPos = getCellPosition(fallInfo.toRow, fallInfo.col);
+		tween(fallInfo.cell, {
+			y: newPos.y
+		}, {
+			duration: animationDuration,
+			easing: tween.easeInOutQuad
+		});
+	}
+	// If no cells to fall, proceed immediately to filling empty spaces
+	if (cellsToFall.length === 0) {
 		window.gravityInProgress = false;
-		if (!window.destructionInProgress) {
+		fillEmptySpacesWithNewMemes();
+	} else {
+		// Wait for animations to complete before proceeding
+		LK.setTimeout(function () {
+			window.gravityInProgress = false;
 			fillEmptySpacesWithNewMemes();
-		}
-	}, longestDelay + 50);
-}
-function processGridForGravity(cellsToFall) {
-	for (var col = 0; col < gridSize; col++) {
-		for (var row = gridSize + extraRows - 1; row >= extraRows; row--) {
-			if (!gridCells[row][col]) {
-				var sourceRow = row - 1;
-				while (sourceRow >= 0 && !gridCells[sourceRow][col]) {
-					sourceRow--;
-				}
-				if (sourceRow >= 0) {
-					var cellToMove = gridCells[sourceRow][col];
-					if (cellToMove) {
-						cellsToFall.push({
-							cell: cellToMove,
-							fromRow: sourceRow,
-							toRow: row,
-							col: col
-						});
-						// Update grid data
-						gridCells[row][col] = cellToMove;
-						gridCells[sourceRow][col] = null;
-						cellToMove.row = row;
-						// Make hidden cells visible
-						if (sourceRow < extraRows) {
-							gridContainer.addChild(cellToMove);
-						}
-					}
-				}
-			}
-		}
+		}, animationDuration + 20);
 	}
 }
-function animateFallingCells(cellsToFall, baseDelay, duration) {
-	var longestDelay = 0;
-	cellsToFall.forEach(function (fallInfo, index) {
-		var delay = index * baseDelay;
-		var newPos = getCellPosition(fallInfo.toRow, fallInfo.col);
-		var totalTime = delay + duration;
-		if (totalTime > longestDelay) {
-			longestDelay = totalTime;
-		}
-		LK.setTimeout(function () {
-			if (isValidCell(fallInfo.cell)) {
-				tween(fallInfo.cell, {
-					y: newPos.y
-				}, {
-					duration: duration,
-					easing: tween.linear
-				});
-			}
-		}, delay);
-	});
-	return longestDelay;
-}
 function fillEmptySpacesWithNewMemes() {
+	// Early return if operations are already in progress
 	if (window.fillInProgress || window.gravityInProgress) {
 		return;
 	}
 	window.fillInProgress = true;
-	// Create and add new cells
-	var newCellsToAdd = createNewCells();
-	var anyNewMemeAdded = newCellsToAdd.length > 0;
-	// Animation constants
-	var baseDelay = 30;
-	var constantDuration = 400;
-	// Sort cells for consistent animation
-	newCellsToAdd.sort(function (a, b) {
-		if (a.col !== b.col) {
-			return a.col - b.col;
-		}
-		return b.row - a.row;
-	});
-	// Animate new cells
-	var longestDelay = animateNewCells(newCellsToAdd, baseDelay, constantDuration);
-	// Handle completion
-	if (anyNewMemeAdded) {
-		LK.setTimeout(function () {
-			window.fillInProgress = false;
-			if (window.destructionInProgress || window.gravityInProgress) {
-				isAnimating = false;
-				return;
-			}
-			processNewMatches();
-		}, longestDelay + 50);
-	} else {
-		window.fillInProgress = false;
-		isAnimating = false;
-		comboInProgress = false;
-		comboCounter = 0;
-	}
-}
-function createNewCells() {
-	var newCells = [];
+	var newCellsToAdd = [];
+	// Find and fill all empty spaces in one pass
 	for (var col = 0; col < gridSize; col++) {
 		for (var row = 0; row < gridSize + extraRows; row++) {
 			if (!gridCells[row][col]) {
 				var newCell = getGridCell();
 				var pos = getCellPosition(row, col);
-				// Configure new cell
+				// Position new cell above the grid for animation
 				newCell.x = pos.x;
-				newCell.y = pos.y - 400; // Start above grid
-				newCell.setValue(Math.floor(Math.random() * 5) + 1);
+				newCell.y = pos.y - 400;
+				// Generate random value while avoiding potential matches
+				var randomValue;
+				var attempts = 0;
+				var leftMatches = 0;
+				var aboveMatches = 0;
+				do {
+					randomValue = Math.floor(Math.random() * 5) + 1;
+					attempts++;
+					// Check horizontal matches
+					if (col >= 2 && gridCells[row][col - 1] && gridCells[row][col - 2] && gridCells[row][col - 1].value === randomValue && gridCells[row][col - 2].value === randomValue) {
+						leftMatches = 2;
+					} else {
+						leftMatches = 0;
+					}
+					// Check vertical matches
+					if (row >= 2 && gridCells[row - 1] && gridCells[row - 2] && gridCells[row - 1][col] && gridCells[row - 2][col] && gridCells[row - 1][col].value === randomValue && gridCells[row - 2][col].value === randomValue) {
+						aboveMatches = 2;
+					} else {
+						aboveMatches = 0;
+					}
+				} while ((leftMatches >= 2 || aboveMatches >= 2) && attempts < 5);
+				newCell.setValue(randomValue);
 				newCell.row = row;
 				newCell.col = col;
-				// Update grid data
 				gridCells[row][col] = newCell;
-				// Track for animation
-				newCells.push({
+				newCellsToAdd.push({
 					cell: newCell,
 					destY: pos.y,
 					row: row,
 					col: col
 				});
-				// Add to visible container if needed
+				// Only add to visible container if in visible area
 				if (row >= extraRows) {
 					gridContainer.addChild(newCell);
 				}
 			}
 		}
 	}
-	return newCells;
-}
-function animateNewCells(cells, baseDelay, duration) {
-	var longestDelay = 0;
-	cells.forEach(function (cellData, index) {
-		var delay = index * baseDelay;
-		var totalTime = delay + duration;
-		if (totalTime > longestDelay) {
-			longestDelay = totalTime;
+	// Use a constant animation duration without delays
+	var animationDuration = 300;
+	// Sort cells for natural falling appearance
+	newCellsToAdd.sort(function (a, b) {
+		if (a.col !== b.col) {
+			return a.col - b.col;
 		}
-		LK.setTimeout(function () {
-			if (isValidCell(cellData.cell)) {
-				tween(cellData.cell, {
-					y: cellData.destY
-				}, {
-					duration: duration,
-					easing: tween.linear
-				});
-			}
-		}, delay);
+		return b.row - a.row;
 	});
-	return longestDelay;
-}
-function processNewMatches() {
-	// Get matches with visible cells
-	var visibleMatchGroups = getMatches().filter(function (group) {
-		return isValidMatchGroup(group);
-	});
-	if (visibleMatchGroups.length > 0) {
-		// Group matches by cell value type
-		var matchesByType = groupMatchesByType(visibleMatchGroups);
-		// Process each match type
-		for (var type in matchesByType) {
-			var typeGroups = matchesByType[type];
-			var centerCell = null;
-			if (typeGroups.length > 0 && typeGroups[0].length > 0) {
-				var matchGroup = typeGroups[0];
-				centerCell = matchGroup[Math.floor(matchGroup.length / 2)];
+	// Start all animations at once
+	for (var i = 0; i < newCellsToAdd.length; i++) {
+		var cellData = newCellsToAdd[i];
+		tween(cellData.cell, {
+			y: cellData.destY
+		}, {
+			duration: animationDuration,
+			easing: tween.easeOutBounce
+		});
+	}
+	// If no new cells, reset states immediately
+	if (newCellsToAdd.length === 0) {
+		window.fillInProgress = false;
+		isAnimating = false;
+		comboInProgress = false;
+		comboCounter = 0;
+		return;
+	}
+	// Check for matches after animation completes
+	LK.setTimeout(function () {
+		window.fillInProgress = false;
+		if (window.destructionInProgress || window.gravityInProgress) {
+			isAnimating = false;
+			return;
+		}
+		// Get only valid, visible matches
+		var matches = getMatches();
+		var visibleMatchGroups = [];
+		for (var i = 0; i < matches.length; i++) {
+			var group = matches[i];
+			var visibleCount = 0;
+			var invisibleCount = 0;
+			for (var j = 0; j < group.length; j++) {
+				if (group[j].row >= extraRows) {
+					visibleCount++;
+				} else {
+					invisibleCount++;
+				}
 			}
-			// Get unique cells of this type
-			var typeCells = getUniqueCellsFromGroups(typeGroups);
-			if (typeCells.length) {
-				destroyCells(typeCells, centerCell);
+			// Only include groups with enough visible cells
+			if (visibleCount >= 3 || visibleCount > 0 && invisibleCount > 0 && visibleCount >= 3) {
+				visibleMatchGroups.push(group);
 			}
 		}
-		if (Object.keys(matchesByType).length === 0) {
+		if (visibleMatchGroups.length > 0) {
+			// Process matches by cell type
+			var cellsByType = {};
+			var processedCells = {};
+			// Group cells by type
+			for (var i = 0; i < visibleMatchGroups.length; i++) {
+				var group = visibleMatchGroups[i];
+				if (group.length === 0) continue;
+				var type = group[0].value;
+				if (!cellsByType[type]) {
+					cellsByType[type] = [];
+				}
+				// Add unique cells
+				for (var j = 0; j < group.length; j++) {
+					var cell = group[j];
+					var cellKey = cell.row + "_" + cell.col;
+					if (!processedCells[cellKey] && cell.row >= extraRows && gridCells[cell.row] && gridCells[cell.row][cell.col] === cell) {
+						cellsByType[type].push(cell);
+						processedCells[cellKey] = true;
+					}
+				}
+			}
+			// Process each type group
+			for (var type in cellsByType) {
+				var cells = cellsByType[type];
+				if (cells.length === 0) continue;
+				// Use middle cell as center
+				var centerCell = cells[Math.floor(cells.length / 2)];
+				destroyCells(cells, centerCell);
+			}
+		} else {
+			// No matches, end animation state
 			isAnimating = false;
+			comboInProgress = false;
+			comboCounter = 0;
 		}
-	} else {
-		isAnimating = false;
-	}
+	}, animationDuration + 20);
 }
-function isValidMatchGroup(group) {
-	var visibleCells = group.filter(function (cell) {
-		return cell.row >= extraRows;
-	});
-	var invisibleCells = group.filter(function (cell) {
-		return cell.row < extraRows;
-	});
-	if (visibleCells.length > 0 && invisibleCells.length > 0 && visibleCells.length < 3) {
-		return false;
-	}
-	return visibleCells.length >= 3;
-}
-function groupMatchesByType(matches) {
-	var matchesByType = {};
-	matches.forEach(function (group) {
-		if (group.length > 0) {
-			var type = group[0].value;
-			if (!matchesByType[type]) {
-				matchesByType[type] = [];
-			}
-			matchesByType[type].push(group);
-		}
-	});
-	return matchesByType;
-}
-function getUniqueCellsFromGroups(groups) {
-	var cells = [];
-	var cellTracker = {};
-	groups.forEach(function (group) {
-		group.forEach(function (cell) {
-			var cellKey = cell.row + "_" + cell.col;
-			if (!cellTracker[cellKey] && isValidCell(cell)) {
-				cells.push(cell);
-				cellTracker[cellKey] = true;
-			}
-		});
-	});
-	return cells;
-}
 function checkForAndDestroyMatches(swappedCellA, swappedCellB) {
+	// Don't process if animations are in progress
 	if (window.gravityInProgress || window.fillInProgress) {
 		return;
 	}
+	// Get all match groups
 	var allMatchGroupsOnBoard = getMatches();
 	if (!allMatchGroupsOnBoard.length) {
 		return;
 	}
-	var relevantMatchGroups = allMatchGroupsOnBoard.filter(function (group) {
-		var visibleCells = group.filter(function (cell) {
-			return cell.row >= extraRows;
-		});
-		var invisibleCells = group.filter(function (cell) {
-			return cell.row < extraRows;
-		});
-		if (visibleCells.length > 0 && invisibleCells.length > 0 && visibleCells.length < 3) {
-			return false;
+	// Find matches that contain the swapped cells and have enough visible cells
+	var relevantMatchGroups = [];
+	var cellsInSwap = [swappedCellA, swappedCellB];
+	for (var i = 0; i < allMatchGroupsOnBoard.length; i++) {
+		var group = allMatchGroupsOnBoard[i];
+		var visibleCount = 0;
+		var invisibleCount = 0;
+		var containsSwappedCell = false;
+		// Count visible cells and check for swapped cells in one pass
+		for (var j = 0; j < group.length; j++) {
+			var cell = group[j];
+			if (cell.row >= extraRows) {
+				visibleCount++;
+				// Check if this cell is one of the swapped cells
+				if (cell === swappedCellA || cell === swappedCellB) {
+					containsSwappedCell = true;
+				}
+			} else {
+				invisibleCount++;
+			}
 		}
-		return group.some(function (cellInGroup) {
-			return (cellInGroup === swappedCellA || cellInGroup === swappedCellB) && cellInGroup.row >= extraRows;
-		});
-	});
+		// Include group if it has enough visible cells and contains a swapped cell
+		if (containsSwappedCell && (visibleCount >= 3 || !(visibleCount > 0 && invisibleCount > 0 && visibleCount < 3))) {
+			relevantMatchGroups.push(group);
+		}
+	}
 	if (!relevantMatchGroups.length) {
 		return;
 	}
-	var matchesByType = {};
-	relevantMatchGroups.forEach(function (group) {
-		if (group.length > 0) {
-			var type = group[0].value;
-			if (!matchesByType[type]) {
-				matchesByType[type] = [];
-			}
-			matchesByType[type].push(group);
-		}
-	});
+	// Process matches efficiently
+	var cellsByType = {};
 	var uniqueCellTracker = {};
-	var cellsToDestroy = [];
-	for (var type in matchesByType) {
-		var typeGroups = matchesByType[type];
-		var typeCells = [];
-		typeGroups.forEach(function (group) {
-			group.forEach(function (cell) {
-				if (cell.row >= extraRows) {
-					typeCells.push(cell);
-				}
-			});
-		});
-		typeCells.forEach(function (cell) {
+	// Group cells by type in one pass
+	for (var i = 0; i < relevantMatchGroups.length; i++) {
+		var group = relevantMatchGroups[i];
+		if (group.length === 0) continue;
+		var type = group[0].value;
+		if (!cellsByType[type]) {
+			cellsByType[type] = [];
+		}
+		// Add unique cells directly
+		for (var j = 0; j < group.length; j++) {
+			var cell = group[j];
+			if (cell.row < extraRows) continue;
 			var cellKey = cell.row + "_" + cell.col;
-			if (!uniqueCellTracker[cellKey] && cell.row >= extraRows && cell && gridCells[cell.row] && gridCells[cell.row][cell.col] === cell) {
-				cellsToDestroy.push(cell);
+			if (!uniqueCellTracker[cellKey] && gridCells[cell.row] && gridCells[cell.row][cell.col] === cell) {
+				cellsByType[type].push(cell);
 				uniqueCellTracker[cellKey] = true;
 			}
-		});
+		}
 	}
-	;
+	// Collect all cells to destroy
+	var cellsToDestroy = [];
+	for (var type in cellsByType) {
+		var typeCells = cellsByType[type];
+		cellsToDestroy = cellsToDestroy.concat(typeCells);
+	}
 	if (cellsToDestroy.length) {
-		var centerCell = swappedCellA && relevantMatchGroups.some(function (group) {
-			return group.includes(swappedCellA);
-		}) ? swappedCellA : swappedCellB;
+		// Determine center cell for special piece creation
+		var centerCell = null;
+		// Prioritize swapped cells that are part of a match
+		if (swappedCellA && uniqueCellTracker[swappedCellA.row + "_" + swappedCellA.col]) {
+			centerCell = swappedCellA;
+		} else if (swappedCellB && uniqueCellTracker[swappedCellB.row + "_" + swappedCellB.col]) {
+			centerCell = swappedCellB;
+		}
+		// Destroy matched cells
 		destroyCells(cellsToDestroy, centerCell);
-		LK.setTimeout(function () {
-			if (window.gravityInProgress || window.fillInProgress) {
-				return;
-			}
-			var visibleMatchGroups = getMatches().filter(function (group) {
-				var visibleCells = group.filter(function (cell) {
-					return cell.row >= extraRows;
-				});
-				var invisibleCells = group.filter(function (cell) {
-					return cell.row < extraRows;
-				});
-				if (visibleCells.length > 0 && invisibleCells.length > 0 && visibleCells.length < 3) {
-					return false;
-				}
-				return visibleCells.length >= 3;
-			});
-			var newMatches = visibleMatchGroups;
-			if (newMatches.length > 0) {
-				var matchesByType = {};
-				newMatches.forEach(function (group) {
-					if (group.length > 0) {
-						var type = group[0].value;
-						if (!matchesByType[type]) {
-							matchesByType[type] = [];
-						}
-						matchesByType[type].push(group);
-					}
-				});
-				for (var type in matchesByType) {
-					var typeGroups = matchesByType[type];
-					var newCellsToDestroy = [];
-					var newCellTracker = {};
-					typeGroups.forEach(function (group) {
-						group.forEach(function (cell) {
-							var cellKey = cell.row + "_" + cell.col;
-							if (!newCellTracker[cellKey] && cell.row >= extraRows && cell && gridCells[cell.row] && gridCells[cell.row][cell.col] === cell) {
-								newCellsToDestroy.push(cell);
-								newCellTracker[cellKey] = true;
-							}
-						});
-					});
-					if (newCellsToDestroy.length) {
-						var centerCell = newCellsToDestroy[Math.floor(newCellsToDestroy.length / 2)];
-						destroyCells(newCellsToDestroy, centerCell);
-					}
-				}
-			}
-		}, 400);
+		// Reset combo at the end of all cascade matches
+		comboInProgress = false;
+		comboCounter = 0;
 	}
 }
 var gridSize = 8;
 var extraRows = 9;