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

/**** 
* Classes
****/ 
var Gem = Container.expand(function (color, isSpecial, specialType) {
	var self = Container.call(this);
	self.gemType = color;
	self.isSpecial = isSpecial || false;
	self.specialType = specialType || null; // 'striped-horizontal' or 'striped-vertical'
	var gemAssetIds = ['redGem', 'blueGem', 'greenGem', 'yellowGem', 'purpleGem', 'orangeGem'];
	var assetId = self.isSpecial ? 'stripedGem' : gemAssetIds[color];
	var gemGraphics = self.attachAsset(assetId, {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Add visual stripe effect for special gems
	if (self.isSpecial) {
		gemGraphics.tint = [0xff4444, 0x4444ff, 0x44ff44, 0xffff44, 0xff44ff, 0xff8844][color];
		// Add sparkle animation
		tween(gemGraphics, {
			scaleX: 1.2,
			scaleY: 1.2
		}, {
			duration: 800,
			easing: tween.easeInOut,
			onFinish: function onFinish() {
				tween(gemGraphics, {
					scaleX: 1,
					scaleY: 1
				}, {
					duration: 800,
					easing: tween.easeInOut
				});
			}
		});
	}
	self.gridX = 0;
	self.gridY = 0;
	self.isAnimating = false;
	self.setGridPosition = function (gridX, gridY) {
		self.gridX = gridX;
		self.gridY = gridY;
		// Update screen position to match grid position
		self.x = GRID_OFFSET_X + gridX * GEM_SIZE + GEM_SIZE / 2;
		self.y = GRID_OFFSET_Y + gridY * GEM_SIZE + GEM_SIZE / 2;
	};
	self.animateToPosition = function (targetX, targetY, onComplete) {
		self.isAnimating = true;
		tween(self, {
			x: targetX,
			y: targetY
		}, {
			duration: 200,
			easing: tween.easeOut,
			onFinish: function onFinish() {
				self.isAnimating = false;
				if (onComplete) onComplete();
			}
		});
	};
	return self;
});

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

/**** 
* Game Code
****/ 
var GRID_SIZE = 8;
var GEM_SIZE = 200;
var GRID_OFFSET_X = (2048 - GRID_SIZE * GEM_SIZE) / 2;
var GRID_OFFSET_Y = 400;
var MOVE_LIMIT = 30;
var grid = [];
var selectedGem = null;
var movesLeft = MOVE_LIMIT;
var isProcessing = false;
var targetGemTypes = [];
var targetAmounts = [];
var collectedAmounts = [];
var objectivePanel = null;
var objectiveTxt = null;
// Initialize score display
var scoreTxt = new Text2('Score: 0', {
	size: 120,
	fill: 0xFFFFFF
});
scoreTxt.anchor.set(0.5, 0);
LK.gui.top.addChild(scoreTxt);
// Initialize moves display
var movesTxt = new Text2('Moves: 30', {
	size: 100,
	fill: 0xFFFF44
});
movesTxt.anchor.set(1, 0);
movesTxt.x = -50;
movesTxt.y = 150;
LK.gui.topRight.addChild(movesTxt);
function getRandomGemType() {
	return Math.floor(Math.random() * 6);
}
function initializeLevelObjectives() {
	// Select 3 random gem types as targets
	var availableTypes = [0, 1, 2, 3, 4, 5];
	targetGemTypes = [];
	targetAmounts = [];
	collectedAmounts = [];
	for (var i = 0; i < 3; i++) {
		var randomIndex = Math.floor(Math.random() * availableTypes.length);
		var selectedType = availableTypes[randomIndex];
		availableTypes.splice(randomIndex, 1);
		targetGemTypes.push(selectedType);
		targetAmounts.push(15 + Math.floor(Math.random() * 10)); // 15-24 gems needed
		collectedAmounts.push(0);
	}
}
function createObjectivePanel() {
	// Create objective panel background
	objectivePanel = new Container();
	objectivePanel.x = 2048 / 2;
	objectivePanel.y = 2732 - 200;
	LK.gui.addChild(objectivePanel);
	// Create objective text
	objectiveTxt = new Text2('Objectives:', {
		size: 80,
		fill: 0xFFFFFF
	});
	objectiveTxt.anchor.set(0.5, 0);
	objectiveTxt.x = 0;
	objectiveTxt.y = -150;
	objectivePanel.addChild(objectiveTxt);
	// Create target gem displays
	for (var i = 0; i < 3; i++) {
		var gemAssetIds = ['redGem', 'blueGem', 'greenGem', 'yellowGem', 'purpleGem', 'orangeGem'];
		var targetGem = LK.getAsset(gemAssetIds[targetGemTypes[i]], {
			anchorX: 0.5,
			anchorY: 0.5,
			scaleX: 0.3,
			scaleY: 0.3
		});
		targetGem.x = (i - 1) * 200;
		targetGem.y = -50;
		objectivePanel.addChild(targetGem);
		var targetText = new Text2('0/' + targetAmounts[i], {
			size: 60,
			fill: 0xFFFFFF
		});
		targetText.anchor.set(0.5, 0);
		targetText.x = (i - 1) * 200;
		targetText.y = 20;
		objectivePanel.addChild(targetText);
	}
}
function updateObjectiveDisplay() {
	// Update the text for each target
	for (var i = 0; i < 3; i++) {
		var textChildIndex = 1 + i * 2 + 1; // title(0) + gem(1) + text(2), gem(3) + text(4), etc.
		var textChild = objectivePanel.children[textChildIndex];
		if (textChild && textChild.setText) {
			textChild.setText(collectedAmounts[i] + '/' + targetAmounts[i]);
		}
	}
}
function checkLevelComplete() {
	for (var i = 0; i < 3; i++) {
		if (collectedAmounts[i] < targetAmounts[i]) {
			return false;
		}
	}
	return true;
}
function createGem(gridX, gridY, isSpecial, specialType) {
	var gemType = getRandomGemType();
	var gem = new Gem(gemType, isSpecial, specialType);
	gem.setGridPosition(gridX, gridY);
	gem.x = GRID_OFFSET_X + gridX * GEM_SIZE + GEM_SIZE / 2;
	gem.y = GRID_OFFSET_Y + gridY * GEM_SIZE + GEM_SIZE / 2;
	return gem;
}
function initializeGrid() {
	for (var y = 0; y < GRID_SIZE; y++) {
		grid[y] = [];
		for (var x = 0; x < GRID_SIZE; x++) {
			var gem = createGem(x, y);
			grid[y][x] = gem;
			game.addChild(gem);
		}
	}
}
function getGridPosition(screenX, screenY) {
	var gridX = Math.floor((screenX - GRID_OFFSET_X) / GEM_SIZE);
	var gridY = Math.floor((screenY - GRID_OFFSET_Y) / GEM_SIZE);
	if (gridX >= 0 && gridX < GRID_SIZE && gridY >= 0 && gridY < GRID_SIZE) {
		return {
			x: gridX,
			y: gridY
		};
	}
	return null;
}
function areAdjacent(gem1, gem2) {
	var dx = Math.abs(gem1.gridX - gem2.gridX);
	var dy = Math.abs(gem1.gridY - gem2.gridY);
	// Only horizontal OR vertical adjacency allowed, not diagonal
	return dx === 1 && dy === 0 || dx === 0 && dy === 1;
}
function swapGems(gem1, gem2) {
	if (isProcessing) return;
	// Check if either gem is a striped gem
	var hasStripedGem = gem1.isSpecial && (gem1.specialType === 'striped-horizontal' || gem1.specialType === 'striped-vertical') || gem2.isSpecial && (gem2.specialType === 'striped-horizontal' || gem2.specialType === 'striped-vertical');
	// Store original positions
	var originalX1 = gem1.gridX;
	var originalY1 = gem1.gridY;
	var originalX2 = gem2.gridX;
	var originalY2 = gem2.gridY;
	var originalScreenX1 = gem1.x;
	var originalScreenY1 = gem1.y;
	var originalScreenX2 = gem2.x;
	var originalScreenY2 = gem2.y;
	// Calculate target positions for the swap animation
	var targetX1 = GRID_OFFSET_X + gem2.gridX * GEM_SIZE + GEM_SIZE / 2;
	var targetY1 = GRID_OFFSET_Y + gem2.gridY * GEM_SIZE + GEM_SIZE / 2;
	var targetX2 = GRID_OFFSET_X + gem1.gridX * GEM_SIZE + GEM_SIZE / 2;
	var targetY2 = GRID_OFFSET_Y + gem1.gridY * GEM_SIZE + GEM_SIZE / 2;
	isProcessing = true;
	LK.getSound('swap').play();
	// Animate the visual swap first
	gem1.animateToPosition(targetX1, targetY1);
	gem2.animateToPosition(targetX2, targetY2, function () {
		// After animation completes, handle the swap
		// Temporarily swap positions
		var tempGridX = gem1.gridX;
		var tempGridY = gem1.gridY;
		gem1.setGridPosition(gem2.gridX, gem2.gridY);
		gem2.setGridPosition(tempGridX, tempGridY);
		grid[gem1.gridY][gem1.gridX] = gem1;
		grid[gem2.gridY][gem2.gridX] = gem2;
		if (hasStripedGem) {
			// If either gem is striped, activate it immediately
			var additionalMatches = [];
			if (gem1.isSpecial && (gem1.specialType === 'striped-horizontal' || gem1.specialType === 'striped-vertical')) {
				var stripedMatches = activateStripedGem(gem1);
				additionalMatches = additionalMatches.concat(stripedMatches);
			}
			if (gem2.isSpecial && (gem2.specialType === 'striped-horizontal' || gem2.specialType === 'striped-vertical')) {
				var stripedMatches = activateStripedGem(gem2);
				additionalMatches = additionalMatches.concat(stripedMatches);
			}
			// Process the striped gem effects
			if (additionalMatches.length > 0) {
				// Award bonus points for striped activation
				LK.setScore(LK.getScore() + additionalMatches.length * 20);
				scoreTxt.setText('Score: ' + LK.getScore());
				// Remove the matched gems
				for (var i = 0; i < additionalMatches.length; i++) {
					var match = additionalMatches[i];
					var gem = grid[match.y][match.x];
					if (gem) {
						// Check if this gem type is a target
						for (var t = 0; t < targetGemTypes.length; t++) {
							if (gem.gemType === targetGemTypes[t]) {
								collectedAmounts[t]++;
							}
						}
						gem.destroy();
						grid[match.y][match.x] = null;
					}
				}
				// Update objective display
				updateObjectiveDisplay();
				// Check if level is complete
				if (checkLevelComplete()) {
					LK.showYouWin();
				}
			}
			isProcessing = false;
			applyGravity();
		} else {
			// Check if this swap creates any matches (for non-striped gems)
			var testMatchData = findMatches();
			if (testMatchData.matches.length === 0 && testMatchData.specialGems.length === 0) {
				// No matches found - animate back to original positions after a delay
				LK.setTimeout(function () {
					// Revert grid positions
					gem1.setGridPosition(originalX1, originalY1);
					gem2.setGridPosition(originalX2, originalY2);
					grid[originalY1][originalX1] = gem1;
					grid[originalY2][originalX2] = gem2;
					// Animate gems back to their original positions
					gem1.animateToPosition(originalScreenX1, originalScreenY1);
					gem2.animateToPosition(originalScreenX2, originalScreenY2, function () {
						isProcessing = false;
					});
				}, 200); // 0.2 second delay before reverting
			} else {
				// Valid swap - continue with match processing
				isProcessing = false;
				processMatches();
			}
		}
	});
}
function findMatches() {
	var matches = [];
	var specialGems = [];
	// Check horizontal matches
	for (var y = 0; y < GRID_SIZE; y++) {
		var count = 1;
		var currentType = grid[y][0].gemType;
		for (var x = 1; x < GRID_SIZE; x++) {
			if (grid[y][x].gemType === currentType) {
				count++;
			} else {
				if (count >= 4) {
					// Create striped gem (horizontal)
					var centerX = Math.floor((x - count + x - 1) / 2);
					specialGems.push({
						x: centerX,
						y: y,
						type: 'striped-horizontal',
						color: currentType
					});
					for (var i = x - count; i < x; i++) {
						if (i !== centerX) {
							// Don't remove the center gem that becomes striped
							matches.push({
								x: i,
								y: y
							});
						}
					}
				} else if (count >= 3) {
					for (var i = x - count; i < x; i++) {
						matches.push({
							x: i,
							y: y
						});
					}
				}
				count = 1;
				currentType = grid[y][x].gemType;
			}
		}
		if (count >= 4) {
			// Create striped gem (horizontal)
			var centerX = Math.floor((GRID_SIZE - count + GRID_SIZE - 1) / 2);
			specialGems.push({
				x: centerX,
				y: y,
				type: 'striped-horizontal',
				color: currentType
			});
			for (var i = GRID_SIZE - count; i < GRID_SIZE; i++) {
				if (i !== centerX) {
					// Don't remove the center gem that becomes striped
					matches.push({
						x: i,
						y: y
					});
				}
			}
		} else if (count >= 3) {
			for (var i = GRID_SIZE - count; i < GRID_SIZE; i++) {
				matches.push({
					x: i,
					y: y
				});
			}
		}
	}
	// Check vertical matches
	for (var x = 0; x < GRID_SIZE; x++) {
		var count = 1;
		var currentType = grid[0][x].gemType;
		for (var y = 1; y < GRID_SIZE; y++) {
			if (grid[y][x].gemType === currentType) {
				count++;
			} else {
				if (count >= 4) {
					// Create striped gem (vertical)
					var centerY = Math.floor((y - count + y - 1) / 2);
					specialGems.push({
						x: x,
						y: centerY,
						type: 'striped-vertical',
						color: currentType
					});
					for (var i = y - count; i < y; i++) {
						if (i !== centerY) {
							// Don't remove the center gem that becomes striped
							matches.push({
								x: x,
								y: i
							});
						}
					}
				} else if (count >= 3) {
					for (var i = y - count; i < y; i++) {
						matches.push({
							x: x,
							y: i
						});
					}
				}
				count = 1;
				currentType = grid[y][x].gemType;
			}
		}
		if (count >= 4) {
			// Create striped gem (vertical)
			var centerY = Math.floor((GRID_SIZE - count + GRID_SIZE - 1) / 2);
			specialGems.push({
				x: x,
				y: centerY,
				type: 'striped-vertical',
				color: currentType
			});
			for (var i = GRID_SIZE - count; i < GRID_SIZE; i++) {
				if (i !== centerY) {
					// Don't remove the center gem that becomes striped
					matches.push({
						x: x,
						y: i
					});
				}
			}
		} else if (count >= 3) {
			for (var i = GRID_SIZE - count; i < GRID_SIZE; i++) {
				matches.push({
					x: x,
					y: i
				});
			}
		}
	}
	return {
		matches: matches,
		specialGems: specialGems
	};
}
function activateStripedGem(gem) {
	var matches = [];
	LK.getSound('lineBlast').play();
	if (gem.specialType === 'striped-horizontal') {
		// Clear entire row
		for (var x = 0; x < GRID_SIZE; x++) {
			if (grid[gem.gridY][x]) {
				matches.push({
					x: x,
					y: gem.gridY
				});
			}
		}
		// Create line effect animation
		var lineEffect = LK.getAsset('stripedGem', {
			anchorX: 0,
			anchorY: 0.5,
			scaleX: 10,
			scaleY: 0.2,
			alpha: 0.8
		});
		lineEffect.x = GRID_OFFSET_X;
		lineEffect.y = GRID_OFFSET_Y + gem.gridY * GEM_SIZE + GEM_SIZE / 2;
		lineEffect.tint = 0xffff00;
		game.addChild(lineEffect);
		tween(lineEffect, {
			alpha: 0
		}, {
			duration: 500,
			onFinish: function onFinish() {
				lineEffect.destroy();
			}
		});
	} else if (gem.specialType === 'striped-vertical') {
		// Clear entire column
		for (var y = 0; y < GRID_SIZE; y++) {
			if (grid[y][gem.gridX]) {
				matches.push({
					x: gem.gridX,
					y: y
				});
			}
		}
		// Create line effect animation
		var lineEffect = LK.getAsset('stripedGem', {
			anchorX: 0.5,
			anchorY: 0,
			scaleX: 0.2,
			scaleY: 10,
			alpha: 0.8
		});
		lineEffect.x = GRID_OFFSET_X + gem.gridX * GEM_SIZE + GEM_SIZE / 2;
		lineEffect.y = GRID_OFFSET_Y;
		lineEffect.tint = 0xffff00;
		game.addChild(lineEffect);
		tween(lineEffect, {
			alpha: 0
		}, {
			duration: 500,
			onFinish: function onFinish() {
				lineEffect.destroy();
			}
		});
	}
	return matches;
}
function removeMatches(matchData) {
	var matches = matchData.matches || matchData;
	var specialGems = matchData.specialGems || [];
	if (matches.length === 0 && specialGems.length === 0) return;
	LK.getSound('match').play();
	var points = matches.length * 10;
	// Bonus points for special gem creation
	if (specialGems.length > 0) {
		points += specialGems.length * 50;
	}
	LK.setScore(LK.getScore() + points);
	scoreTxt.setText('Score: ' + LK.getScore());
	// Check for striped gems being matched and activate their effects
	var additionalMatches = [];
	for (var i = 0; i < matches.length; i++) {
		var match = matches[i];
		var gem = grid[match.y][match.x];
		if (gem && gem.isSpecial && (gem.specialType === 'striped-horizontal' || gem.specialType === 'striped-vertical')) {
			var stripedMatches = activateStripedGem(gem);
			additionalMatches = additionalMatches.concat(stripedMatches);
		}
	}
	// Track collected target gems
	for (var i = 0; i < matches.length; i++) {
		var match = matches[i];
		var gem = grid[match.y][match.x];
		if (gem) {
			// Check if this gem type is a target
			for (var t = 0; t < targetGemTypes.length; t++) {
				if (gem.gemType === targetGemTypes[t]) {
					collectedAmounts[t]++;
				}
			}
			gem.destroy();
			grid[match.y][match.x] = null;
		}
	}
	// Create special striped gems
	for (var i = 0; i < specialGems.length; i++) {
		var special = specialGems[i];
		var stripedGem = createGem(special.x, special.y, true, special.type);
		stripedGem.gemType = special.color;
		grid[special.y][special.x] = stripedGem;
		game.addChild(stripedGem);
	}
	// Process additional matches from striped gem activations
	if (additionalMatches.length > 0) {
		for (var i = 0; i < additionalMatches.length; i++) {
			var match = additionalMatches[i];
			var gem = grid[match.y][match.x];
			if (gem) {
				// Check if this gem type is a target
				for (var t = 0; t < targetGemTypes.length; t++) {
					if (gem.gemType === targetGemTypes[t]) {
						collectedAmounts[t]++;
					}
				}
				gem.destroy();
				grid[match.y][match.x] = null;
			}
		}
		// Add bonus points for striped gem activation
		LK.setScore(LK.getScore() + additionalMatches.length * 20);
		scoreTxt.setText('Score: ' + LK.getScore());
	}
	// Update objective display
	updateObjectiveDisplay();
	// Check if level is complete
	if (checkLevelComplete()) {
		LK.showYouWin();
	}
}
function applyGravity() {
	// First pass: clear all null positions and compact gems downward
	for (var x = 0; x < GRID_SIZE; x++) {
		var compactedGems = [];
		// Collect all non-null gems from this column
		for (var y = 0; y < GRID_SIZE; y++) {
			if (grid[y][x] !== null) {
				compactedGems.push(grid[y][x]);
			}
			// Clear the grid position
			grid[y][x] = null;
		}
		// Place compacted gems at the bottom of the column
		var startY = GRID_SIZE - compactedGems.length;
		for (var i = 0; i < compactedGems.length; i++) {
			var newY = startY + i;
			var gem = compactedGems[i];
			grid[newY][x] = gem;
			gem.setGridPosition(x, newY);
		}
	}
	// Second pass: create new gems for empty positions at top
	var gemsToAnimate = [];
	for (var x = 0; x < GRID_SIZE; x++) {
		for (var y = 0; y < GRID_SIZE; y++) {
			if (grid[y][x] === null) {
				var newGem = createGem(x, y);
				// Start new gems above the visible area
				newGem.y = GRID_OFFSET_Y - (GRID_SIZE - y) * GEM_SIZE + GEM_SIZE / 2;
				grid[y][x] = newGem;
				game.addChild(newGem);
				var targetY = GRID_OFFSET_Y + y * GEM_SIZE + GEM_SIZE / 2;
				gemsToAnimate.push({
					gem: newGem,
					targetY: targetY
				});
			}
		}
	}
	// Third pass: animate all existing gems to their correct positions
	for (var x = 0; x < GRID_SIZE; x++) {
		for (var y = 0; y < GRID_SIZE; y++) {
			var gem = grid[y][x];
			if (gem && !gem.isAnimating) {
				var correctY = GRID_OFFSET_Y + y * GEM_SIZE + GEM_SIZE / 2;
				if (Math.abs(gem.y - correctY) > 5) {
					// Only animate if position is significantly different
					gemsToAnimate.push({
						gem: gem,
						targetY: correctY
					});
				}
			}
		}
	}
	// Animate all gems that need repositioning
	if (gemsToAnimate.length > 0) {
		isProcessing = true;
		var animationsComplete = 0;
		for (var i = 0; i < gemsToAnimate.length; i++) {
			var animData = gemsToAnimate[i];
			tween(animData.gem, {
				y: animData.targetY
			}, {
				duration: 300,
				easing: tween.easeOut,
				onFinish: function onFinish() {
					animationsComplete++;
					if (animationsComplete === gemsToAnimate.length) {
						isProcessing = false;
						processMatches();
					}
				}
			});
		}
	} else {
		// No animations needed, check for matches immediately
		processMatches();
	}
}
function validateGridSync() {
	// Verify that each grid position contains exactly one gem with correct coordinates
	for (var y = 0; y < GRID_SIZE; y++) {
		for (var x = 0; x < GRID_SIZE; x++) {
			var gem = grid[y][x];
			if (!gem) {
				console.error("Missing gem at grid position", x, y);
				return false;
			}
			if (gem.gridX !== x || gem.gridY !== y) {
				console.error("Gem position mismatch at", x, y, "gem thinks it's at", gem.gridX, gem.gridY);
				gem.setGridPosition(x, y); // Fix the mismatch
			}
		}
	}
	return true;
}
function processMatches() {
	// Validate grid synchronization before processing matches
	validateGridSync();
	var matchData = findMatches();
	if (matchData.matches.length > 0 || matchData.specialGems.length > 0) {
		removeMatches(matchData);
		applyGravity();
	}
}
function decrementMoves() {
	movesLeft--;
	movesTxt.setText('Moves: ' + movesLeft);
	if (movesLeft <= 0) {
		if (checkLevelComplete()) {
			LK.showYouWin();
		} else {
			LK.showGameOver();
		}
	}
}
var dragStartGem = null;
game.down = function (x, y, obj) {
	if (isProcessing) return;
	var gridPos = getGridPosition(x, y);
	if (!gridPos) return;
	var clickedGem = grid[gridPos.y][gridPos.x];
	if (!clickedGem) return;
	// Store the gem being dragged
	dragStartGem = clickedGem;
	if (selectedGem === null) {
		selectedGem = clickedGem;
		tween(selectedGem, {
			scaleX: 1.1,
			scaleY: 1.1
		}, {
			duration: 150
		});
	} else if (selectedGem === clickedGem) {
		tween(selectedGem, {
			scaleX: 1,
			scaleY: 1
		}, {
			duration: 150
		});
		selectedGem = null;
	} else if (areAdjacent(selectedGem, clickedGem)) {
		tween(selectedGem, {
			scaleX: 1,
			scaleY: 1
		}, {
			duration: 150
		});
		swapGems(selectedGem, clickedGem);
		decrementMoves();
		selectedGem = null;
	} else {
		tween(selectedGem, {
			scaleX: 1,
			scaleY: 1
		}, {
			duration: 150
		});
		selectedGem = clickedGem;
		tween(selectedGem, {
			scaleX: 1.1,
			scaleY: 1.1
		}, {
			duration: 150
		});
	}
};
game.up = function (x, y, obj) {
	if (isProcessing || !dragStartGem) return;
	var gridPos = getGridPosition(x, y);
	if (!gridPos) {
		dragStartGem = null;
		return;
	}
	var targetGem = grid[gridPos.y][gridPos.x];
	if (!targetGem || targetGem === dragStartGem) {
		dragStartGem = null;
		return;
	}
	// Only allow swap if gems are adjacent (horizontal or vertical only)
	if (areAdjacent(dragStartGem, targetGem)) {
		// Clear any existing selection
		if (selectedGem) {
			tween(selectedGem, {
				scaleX: 1,
				scaleY: 1
			}, {
				duration: 150
			});
			selectedGem = null;
		}
		swapGems(dragStartGem, targetGem);
		decrementMoves();
	} else {
		// If not adjacent, do nothing - invalid move
	}
	dragStartGem = null;
};
// Initialize the game
initializeLevelObjectives();
initializeGrid();
createObjectivePanel();
scoreTxt.setText('Score: ' + LK.getScore());

===================================================================
--- original.js
+++ change.js
@@ -43,8 +43,11 @@
 	self.isAnimating = false;
 	self.setGridPosition = function (gridX, gridY) {
 		self.gridX = gridX;
 		self.gridY = gridY;
+		// Update screen position to match grid position
+		self.x = GRID_OFFSET_X + gridX * GEM_SIZE + GEM_SIZE / 2;
+		self.y = GRID_OFFSET_Y + gridY * GEM_SIZE + GEM_SIZE / 2;
 	};
 	self.animateToPosition = function (targetX, targetY, onComplete) {
 		self.isAnimating = true;
 		tween(self, {
@@ -582,41 +585,63 @@
 		LK.showYouWin();
 	}
 }
 function applyGravity() {
-	var gemsToAnimate = [];
+	// First pass: clear all null positions and compact gems downward
 	for (var x = 0; x < GRID_SIZE; x++) {
-		var writeIndex = GRID_SIZE - 1;
-		// Move existing gems down
-		for (var y = GRID_SIZE - 1; y >= 0; y--) {
+		var compactedGems = [];
+		// Collect all non-null gems from this column
+		for (var y = 0; y < GRID_SIZE; y++) {
 			if (grid[y][x] !== null) {
-				if (y !== writeIndex) {
-					grid[writeIndex][x] = grid[y][x];
-					grid[y][x] = null;
-					grid[writeIndex][x].setGridPosition(x, writeIndex);
-					var targetY = GRID_OFFSET_Y + writeIndex * GEM_SIZE + GEM_SIZE / 2;
+				compactedGems.push(grid[y][x]);
+			}
+			// Clear the grid position
+			grid[y][x] = null;
+		}
+		// Place compacted gems at the bottom of the column
+		var startY = GRID_SIZE - compactedGems.length;
+		for (var i = 0; i < compactedGems.length; i++) {
+			var newY = startY + i;
+			var gem = compactedGems[i];
+			grid[newY][x] = gem;
+			gem.setGridPosition(x, newY);
+		}
+	}
+	// Second pass: create new gems for empty positions at top
+	var gemsToAnimate = [];
+	for (var x = 0; x < GRID_SIZE; x++) {
+		for (var y = 0; y < GRID_SIZE; y++) {
+			if (grid[y][x] === null) {
+				var newGem = createGem(x, y);
+				// Start new gems above the visible area
+				newGem.y = GRID_OFFSET_Y - (GRID_SIZE - y) * GEM_SIZE + GEM_SIZE / 2;
+				grid[y][x] = newGem;
+				game.addChild(newGem);
+				var targetY = GRID_OFFSET_Y + y * GEM_SIZE + GEM_SIZE / 2;
+				gemsToAnimate.push({
+					gem: newGem,
+					targetY: targetY
+				});
+			}
+		}
+	}
+	// Third pass: animate all existing gems to their correct positions
+	for (var x = 0; x < GRID_SIZE; x++) {
+		for (var y = 0; y < GRID_SIZE; y++) {
+			var gem = grid[y][x];
+			if (gem && !gem.isAnimating) {
+				var correctY = GRID_OFFSET_Y + y * GEM_SIZE + GEM_SIZE / 2;
+				if (Math.abs(gem.y - correctY) > 5) {
+					// Only animate if position is significantly different
 					gemsToAnimate.push({
-						gem: grid[writeIndex][x],
-						targetY: targetY
+						gem: gem,
+						targetY: correctY
 					});
 				}
-				writeIndex--;
 			}
 		}
-		// Create new gems for empty spaces at top
-		for (var y = writeIndex; y >= 0; y--) {
-			var newGem = createGem(x, y);
-			newGem.y = GRID_OFFSET_Y - (writeIndex - y + 1) * GEM_SIZE + GEM_SIZE / 2;
-			grid[y][x] = newGem;
-			game.addChild(newGem);
-			var targetY = GRID_OFFSET_Y + y * GEM_SIZE + GEM_SIZE / 2;
-			gemsToAnimate.push({
-				gem: newGem,
-				targetY: targetY
-			});
-		}
 	}
-	// Animate all gems
+	// Animate all gems that need repositioning
 	if (gemsToAnimate.length > 0) {
 		isProcessing = true;
 		var animationsComplete = 0;
 		for (var i = 0; i < gemsToAnimate.length; i++) {
@@ -634,11 +659,33 @@
 					}
 				}
 			});
 		}
+	} else {
+		// No animations needed, check for matches immediately
+		processMatches();
 	}
 }
+function validateGridSync() {
+	// Verify that each grid position contains exactly one gem with correct coordinates
+	for (var y = 0; y < GRID_SIZE; y++) {
+		for (var x = 0; x < GRID_SIZE; x++) {
+			var gem = grid[y][x];
+			if (!gem) {
+				console.error("Missing gem at grid position", x, y);
+				return false;
+			}
+			if (gem.gridX !== x || gem.gridY !== y) {
+				console.error("Gem position mismatch at", x, y, "gem thinks it's at", gem.gridX, gem.gridY);
+				gem.setGridPosition(x, y); // Fix the mismatch
+			}
+		}
+	}
+	return true;
+}
 function processMatches() {
+	// Validate grid synchronization before processing matches
+	validateGridSync();
 	var matchData = findMatches();
 	if (matchData.matches.length > 0 || matchData.specialGems.length > 0) {
 		removeMatches(matchData);
 		applyGravity();