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

/**** 
* Classes
****/ 
var Candy = Container.expand(function (type, gridX, gridY) {
	var self = Container.call(this);
	self.candyType = type;
	self.gridX = gridX;
	self.gridY = gridY;
	self.isMoving = false;
	self.isMarkedForDestroy = false;
	var candyGraphics = self.attachAsset('candy_' + type, {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.moveTo = function (newGridX, newGridY, duration) {
		self.gridX = newGridX;
		self.gridY = newGridY;
		self.isMoving = true;
		var targetX = GRID_START_X + newGridX * CELL_SIZE + CELL_SIZE / 2;
		var targetY = GRID_START_Y + newGridY * CELL_SIZE + CELL_SIZE / 2;
		tween(self, {
			x: targetX,
			y: targetY
		}, {
			duration: duration || 300,
			easing: tween.easeOut,
			onFinish: function onFinish() {
				self.isMoving = false;
			}
		});
	};
	self.destroy = function () {
		self.isMarkedForDestroy = true;
		tween(self, {
			scaleX: 0,
			scaleY: 0,
			alpha: 0
		}, {
			duration: 200,
			easing: tween.easeIn,
			onFinish: function onFinish() {
				if (self.parent) {
					self.parent.removeChild(self);
				}
			}
		});
	};
	return self;
});
var GridCell = Container.expand(function (gridX, gridY) {
	var self = Container.call(this);
	self.gridX = gridX;
	self.gridY = gridY;
	var cellGraphics = self.attachAsset('grid_cell', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	cellGraphics.alpha = 0.3;
	return self;
});

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

/**** 
* Game Code
****/ 
// Decorative elements
// Beautiful gradient background layers
// Create beautiful gradient background
var backgroundContainer = new Container();
game.addChild(backgroundContainer);
// Create multiple layers for depth
var bgLayer1 = LK.getAsset('bg_gradient1', {
	width: 2048,
	height: 2732,
	anchorX: 0,
	anchorY: 0,
	x: 0,
	y: 0
});
var bgLayer2 = LK.getAsset('bg_gradient2', {
	width: 2048,
	height: 2732,
	anchorX: 0,
	anchorY: 0,
	x: 0,
	y: 0
});
var bgLayer3 = LK.getAsset('bg_pattern', {
	width: 2048,
	height: 2732,
	anchorX: 0,
	anchorY: 0,
	x: 0,
	y: 0
});
backgroundContainer.addChild(bgLayer1);
backgroundContainer.addChild(bgLayer2);
backgroundContainer.addChild(bgLayer3);
// Set transparency for layering effect
bgLayer2.alpha = 0.7;
bgLayer3.alpha = 0.3;
var GRID_WIDTH = 10;
var GRID_HEIGHT = 10;
var CELL_SIZE = 150;
var GRID_START_X = (2048 - GRID_WIDTH * CELL_SIZE) / 2;
var GRID_START_Y = 650;
var CANDY_TYPES = ['red', 'blue', 'green', 'yellow', 'purple', 'orange'];
var grid = [];
var candies = [];
var selectedCandy = null;
var draggedCandy = null;
var isDragging = false;
var dragStartX = 0;
var dragStartY = 0;
var movesLeft = 20;
var currentScore = 0;
var targetScore = 1000;
var isProcessing = false;
var currentLevel = 1;
var maxLevel = 1;
// Level configurations
var levelConfigs = [{
	level: 1,
	targetScore: 1000,
	moves: 20,
	gridSize: 10
}, {
	level: 2,
	targetScore: 1500,
	moves: 18,
	gridSize: 10
}, {
	level: 3,
	targetScore: 2000,
	moves: 16,
	gridSize: 10
}, {
	level: 4,
	targetScore: 2500,
	moves: 15,
	gridSize: 10
}, {
	level: 5,
	targetScore: 3000,
	moves: 14,
	gridSize: 10
}, {
	level: 6,
	targetScore: 3500,
	moves: 13,
	gridSize: 10
}, {
	level: 7,
	targetScore: 4000,
	moves: 12,
	gridSize: 10
}, {
	level: 8,
	targetScore: 4500,
	moves: 11,
	gridSize: 10
}, {
	level: 9,
	targetScore: 5000,
	moves: 10,
	gridSize: 10
}, {
	level: 10,
	targetScore: 6000,
	moves: 10,
	gridSize: 10
}];
// Initialize grid cells
for (var y = 0; y < GRID_HEIGHT; y++) {
	grid[y] = [];
	for (var x = 0; x < GRID_WIDTH; x++) {
		var cell = new GridCell(x, y);
		cell.x = GRID_START_X + x * CELL_SIZE + CELL_SIZE / 2;
		cell.y = GRID_START_Y + y * CELL_SIZE + CELL_SIZE / 2;
		game.addChild(cell);
		grid[y][x] = null;
	}
}
// UI Elements - Score with button background
var scoreButtonBorder = LK.getAsset('score_button_border', {
	anchorX: 0.5,
	anchorY: 0.5
});
var scoreButtonBg = LK.getAsset('score_button_bg', {
	anchorX: 0.5,
	anchorY: 0.5
});
var scoreButtonHighlight = LK.getAsset('score_button_highlight', {
	anchorX: 0.5,
	anchorY: 0.5
});
// Create score button container
var scoreButtonContainer = new Container();
scoreButtonContainer.addChild(scoreButtonBorder);
scoreButtonContainer.addChild(scoreButtonBg);
scoreButtonContainer.addChild(scoreButtonHighlight);
// Position button elements
scoreButtonBorder.y = 0;
scoreButtonBg.y = -2;
scoreButtonHighlight.y = -5;
scoreButtonHighlight.alpha = 0.6;
// Add gradient effect with tween
tween(scoreButtonHighlight, {
	alpha: 0.3
}, {
	duration: 2000,
	easing: tween.easeInOut,
	onFinish: function onFinish() {
		tween(scoreButtonHighlight, {
			alpha: 0.6
		}, {
			duration: 2000,
			easing: tween.easeInOut
		});
	}
});
var scoreText = new Text2('Score: 0', {
	size: 60,
	fill: 0xFFFFFF
});
scoreText.anchor.set(0.5, 0.5);
scoreButtonContainer.addChild(scoreText);
LK.gui.top.addChild(scoreButtonContainer);
scoreButtonContainer.y = 90;
// UI Elements - Moves with button background
var movesButtonBorder = LK.getAsset('score_button_border', {
	anchorX: 0.5,
	anchorY: 0.5,
	scaleX: 0.8,
	scaleY: 0.8
});
var movesButtonBg = LK.getAsset('score_button_bg', {
	anchorX: 0.5,
	anchorY: 0.5,
	scaleX: 0.8,
	scaleY: 0.8
});
var movesButtonHighlight = LK.getAsset('score_button_highlight', {
	anchorX: 0.5,
	anchorY: 0.5,
	scaleX: 0.8,
	scaleY: 0.8
});
// Create moves button container
var movesButtonContainer = new Container();
movesButtonContainer.addChild(movesButtonBorder);
movesButtonContainer.addChild(movesButtonBg);
movesButtonContainer.addChild(movesButtonHighlight);
// Position button elements
movesButtonBorder.y = 0;
movesButtonBg.y = -2;
movesButtonHighlight.y = -5;
movesButtonHighlight.alpha = 0.6;
// Add gradient effect with tween
tween(movesButtonHighlight, {
	alpha: 0.3
}, {
	duration: 2200,
	easing: tween.easeInOut,
	onFinish: function onFinish() {
		tween(movesButtonHighlight, {
			alpha: 0.6
		}, {
			duration: 2200,
			easing: tween.easeInOut
		});
	}
});
var movesText = new Text2('Moves: ' + movesLeft, {
	size: 50,
	fill: 0xFFFFFF
});
movesText.anchor.set(0.5, 0.5);
movesButtonContainer.addChild(movesText);
LK.gui.top.addChild(movesButtonContainer);
movesButtonContainer.y = 180;
// UI Elements - Target with button background
var targetButtonBorder = LK.getAsset('score_button_border', {
	anchorX: 0.5,
	anchorY: 0.5,
	scaleX: 0.7,
	scaleY: 0.7
});
var targetButtonBg = LK.getAsset('score_button_bg', {
	anchorX: 0.5,
	anchorY: 0.5,
	scaleX: 0.7,
	scaleY: 0.7
});
var targetButtonHighlight = LK.getAsset('score_button_highlight', {
	anchorX: 0.5,
	anchorY: 0.5,
	scaleX: 0.7,
	scaleY: 0.7
});
// Create target button container
var targetButtonContainer = new Container();
targetButtonContainer.addChild(targetButtonBorder);
targetButtonContainer.addChild(targetButtonBg);
targetButtonContainer.addChild(targetButtonHighlight);
// Position button elements
targetButtonBorder.y = 0;
targetButtonBg.y = -2;
targetButtonHighlight.y = -5;
targetButtonHighlight.alpha = 0.6;
// Add gradient effect with tween
tween(targetButtonHighlight, {
	alpha: 0.3
}, {
	duration: 2400,
	easing: tween.easeInOut,
	onFinish: function onFinish() {
		tween(targetButtonHighlight, {
			alpha: 0.6
		}, {
			duration: 2400,
			easing: tween.easeInOut
		});
	}
});
var targetText = new Text2('Target: ' + targetScore, {
	size: 40,
	fill: 0xFFDD44
});
targetText.anchor.set(0.5, 0.5);
targetButtonContainer.addChild(targetText);
LK.gui.top.addChild(targetButtonContainer);
targetButtonContainer.y = 260;
// UI Elements - Level with button background
var levelButtonBorder = LK.getAsset('score_button_border', {
	anchorX: 0.5,
	anchorY: 0.5,
	scaleX: 0.6,
	scaleY: 0.6
});
var levelButtonBg = LK.getAsset('score_button_bg', {
	anchorX: 0.5,
	anchorY: 0.5,
	scaleX: 0.6,
	scaleY: 0.6
});
var levelButtonHighlight = LK.getAsset('score_button_highlight', {
	anchorX: 0.5,
	anchorY: 0.5,
	scaleX: 0.6,
	scaleY: 0.6
});
// Create level button container
var levelButtonContainer = new Container();
levelButtonContainer.addChild(levelButtonBorder);
levelButtonContainer.addChild(levelButtonBg);
levelButtonContainer.addChild(levelButtonHighlight);
// Position button elements
levelButtonBorder.y = 0;
levelButtonBg.y = -2;
levelButtonHighlight.y = -5;
levelButtonHighlight.alpha = 0.6;
// Add gradient effect with tween
tween(levelButtonHighlight, {
	alpha: 0.3
}, {
	duration: 2600,
	easing: tween.easeInOut,
	onFinish: function onFinish() {
		tween(levelButtonHighlight, {
			alpha: 0.6
		}, {
			duration: 2600,
			easing: tween.easeInOut
		});
	}
});
var levelText = new Text2('Level: ' + currentLevel, {
	size: 50,
	fill: 0x00FF00
});
levelText.anchor.set(0.5, 0.5);
levelButtonContainer.addChild(levelText);
LK.gui.top.addChild(levelButtonContainer);
levelButtonContainer.y = 330;
function getRandomCandyType() {
	return CANDY_TYPES[Math.floor(Math.random() * CANDY_TYPES.length)];
}
function loadProgress() {
	var savedLevel = storage.currentLevel;
	var savedMaxLevel = storage.maxLevel;
	if (savedLevel) {
		currentLevel = parseInt(savedLevel);
	}
	if (savedMaxLevel) {
		maxLevel = parseInt(savedMaxLevel);
	}
}
function saveProgress() {
	storage.currentLevel = currentLevel.toString();
	storage.maxLevel = maxLevel.toString();
}
function getCurrentLevelConfig() {
	if (currentLevel <= levelConfigs.length) {
		return levelConfigs[currentLevel - 1];
	}
	// For levels beyond predefined configs, generate dynamic difficulty
	return {
		level: currentLevel,
		targetScore: 1000 + (currentLevel - 1) * 750,
		moves: Math.max(8, 20 - Math.floor(currentLevel / 2)),
		gridSize: 10
	};
}
function initializeLevel() {
	var config = getCurrentLevelConfig();
	targetScore = config.targetScore;
	movesLeft = config.moves;
	currentScore = 0;
	// Update UI
	levelText.setText('Level: ' + currentLevel);
	scoreText.setText('Score: 0');
	movesText.setText('Moves: ' + movesLeft);
	targetText.setText('Target: ' + targetScore);
	// Clear existing candies
	for (var i = candies.length - 1; i >= 0; i--) {
		var candy = candies[i];
		if (candy.parent) {
			candy.parent.removeChild(candy);
		}
	}
	candies = [];
	// Reset grid
	for (var y = 0; y < GRID_HEIGHT; y++) {
		for (var x = 0; x < GRID_WIDTH; x++) {
			grid[y][x] = null;
		}
	}
	// Initialize new grid
	initializeGrid();
}
function completeLevel() {
	if (currentLevel >= maxLevel) {
		maxLevel = currentLevel + 1;
	}
	currentLevel++;
	saveProgress();
	// Show level complete message briefly before starting next level
	var levelCompleteText = new Text2('Level Complete!', {
		size: 80,
		fill: 0x00FF00
	});
	levelCompleteText.anchor.set(0.5, 0.5);
	levelCompleteText.x = 2048 / 2;
	levelCompleteText.y = 2732 / 2;
	game.addChild(levelCompleteText);
	// Animate text
	levelCompleteText.scaleX = 0;
	levelCompleteText.scaleY = 0;
	tween(levelCompleteText, {
		scaleX: 1,
		scaleY: 1,
		alpha: 1
	}, {
		duration: 500,
		easing: tween.easeOut,
		onFinish: function onFinish() {
			tween(levelCompleteText, {
				scaleX: 0,
				scaleY: 0,
				alpha: 0
			}, {
				duration: 500,
				delay: 1000,
				easing: tween.easeIn,
				onFinish: function onFinish() {
					if (levelCompleteText.parent) {
						levelCompleteText.parent.removeChild(levelCompleteText);
					}
					initializeLevel();
				}
			});
		}
	});
}
function createCandy(x, y, type) {
	type = type || getRandomCandyType();
	var candy = new Candy(type, x, y);
	candy.x = GRID_START_X + x * CELL_SIZE + CELL_SIZE / 2;
	candy.y = GRID_START_Y + y * CELL_SIZE + CELL_SIZE / 2;
	game.addChild(candy);
	candies.push(candy);
	grid[y][x] = candy;
	return candy;
}
function getLevelSpecificCandyType(x, y, level) {
	// Define specific patterns for each level
	switch (level) {
		case 1:
			// Level 1: More red and blue candies in corners
			if (x < 3 && y < 3 || x > 6 && y > 6) {
				return Math.random() < 0.6 ? Math.random() < 0.5 ? 'red' : 'blue' : getRandomCandyType();
			}
			break;
		case 2:
			// Level 2: Checkerboard pattern influence with green and yellow
			if ((x + y) % 2 === 0) {
				return Math.random() < 0.5 ? Math.random() < 0.5 ? 'green' : 'yellow' : getRandomCandyType();
			}
			break;
		case 3:
			// Level 3: Center focus with purple and orange
			var centerDistance = Math.abs(x - 4.5) + Math.abs(y - 4.5);
			if (centerDistance < 4) {
				return Math.random() < 0.7 ? Math.random() < 0.5 ? 'purple' : 'orange' : getRandomCandyType();
			}
			break;
		case 4:
			// Level 4: Diagonal pattern with red and green
			if (Math.abs(x - y) < 2 || Math.abs(x + y - 9) < 2) {
				return Math.random() < 0.6 ? Math.random() < 0.5 ? 'red' : 'green' : getRandomCandyType();
			}
			break;
		case 5:
			// Level 5: Border emphasis with blue and yellow
			if (x < 2 || x > 7 || y < 2 || y > 7) {
				return Math.random() < 0.7 ? Math.random() < 0.5 ? 'blue' : 'yellow' : getRandomCandyType();
			}
			break;
		case 6:
			// Level 6: Cross pattern with purple and red
			if (x === 4 || x === 5 || y === 4 || y === 5) {
				return Math.random() < 0.8 ? Math.random() < 0.5 ? 'purple' : 'red' : getRandomCandyType();
			}
			break;
		case 7:
			// Level 7: Ring pattern with orange and green
			var ringDistance = Math.max(Math.abs(x - 4.5), Math.abs(y - 4.5));
			if (ringDistance > 2 && ringDistance < 5) {
				return Math.random() < 0.6 ? Math.random() < 0.5 ? 'orange' : 'green' : getRandomCandyType();
			}
			break;
		case 8:
			// Level 8: Spiral influence with blue and purple
			var spiralValue = (x * 3 + y * 2) % 7;
			if (spiralValue < 3) {
				return Math.random() < 0.7 ? Math.random() < 0.5 ? 'blue' : 'purple' : getRandomCandyType();
			}
			break;
		case 9:
			// Level 9: Scattered clusters with yellow and red
			if (x % 3 === 0 && y % 3 === 0 || x % 3 === 2 && y % 3 === 2) {
				return Math.random() < 0.8 ? Math.random() < 0.5 ? 'yellow' : 'red' : getRandomCandyType();
			}
			break;
		case 10:
			// Level 10: Complex pattern with all colors but emphasis on green and orange
			if ((x + y) % 4 < 2) {
				return Math.random() < 0.5 ? Math.random() < 0.5 ? 'green' : 'orange' : getRandomCandyType();
			}
			break;
		default:
			// For levels beyond 10, create dynamic patterns based on level number
			var patternType = level % 5;
			switch (patternType) {
				case 0:
					// Diagonal emphasis
					if (Math.abs(x - y) < 3) {
						return Math.random() < 0.6 ? CANDY_TYPES[level % CANDY_TYPES.length] : getRandomCandyType();
					}
					break;
				case 1:
					// Corner concentration
					if (x < 3 && y < 3 || x > 6 && y > 6 || x < 3 && y > 6 || x > 6 && y < 3) {
						return Math.random() < 0.7 ? CANDY_TYPES[(level + 1) % CANDY_TYPES.length] : getRandomCandyType();
					}
					break;
				case 2:
					// Center ring
					var centerDist = Math.max(Math.abs(x - 4.5), Math.abs(y - 4.5));
					if (centerDist > 1 && centerDist < 4) {
						return Math.random() < 0.6 ? CANDY_TYPES[(level + 2) % CANDY_TYPES.length] : getRandomCandyType();
					}
					break;
				case 3:
					// Checkerboard influence
					if ((x + y + level) % 3 === 0) {
						return Math.random() < 0.7 ? CANDY_TYPES[(level + 3) % CANDY_TYPES.length] : getRandomCandyType();
					}
					break;
				case 4:
					// Random clusters
					if ((x * y + level) % 11 < 4) {
						return Math.random() < 0.6 ? CANDY_TYPES[(level + 4) % CANDY_TYPES.length] : getRandomCandyType();
					}
					break;
			}
			break;
	}
	return getRandomCandyType();
}
function initializeGrid() {
	for (var y = 0; y < GRID_HEIGHT; y++) {
		for (var x = 0; x < GRID_WIDTH; x++) {
			var type;
			var attempts = 0;
			do {
				// Use level-specific candy type generation
				type = getLevelSpecificCandyType(x, y, currentLevel);
				attempts++;
				if (attempts > 10) {
					// Fallback to completely random if level pattern is too restrictive
					type = getRandomCandyType();
					break;
				}
			} while (wouldCreateMatch(x, y, type));
			createCandy(x, y, type);
		}
	}
}
function wouldCreateMatch(x, y, type) {
	var horizontalCount = 1;
	var verticalCount = 1;
	// Check horizontal
	var i = x - 1;
	while (i >= 0 && grid[y][i] && grid[y][i].candyType === type) {
		horizontalCount++;
		i--;
	}
	i = x + 1;
	while (i < GRID_WIDTH && grid[y][i] && grid[y][i].candyType === type) {
		horizontalCount++;
		i++;
	}
	// Check vertical
	i = y - 1;
	while (i >= 0 && grid[i][x] && grid[i][x].candyType === type) {
		verticalCount++;
		i--;
	}
	i = y + 1;
	while (i < GRID_HEIGHT && grid[i][x] && grid[i][x].candyType === type) {
		verticalCount++;
		i++;
	}
	return horizontalCount >= 3 || verticalCount >= 3;
}
function findMatches() {
	var matches = [];
	var processed = [];
	for (var y = 0; y < GRID_HEIGHT; y++) {
		processed[y] = [];
		for (var x = 0; x < GRID_WIDTH; x++) {
			processed[y][x] = false;
		}
	}
	// Find horizontal matches
	for (var y = 0; y < GRID_HEIGHT; y++) {
		for (var x = 0; x < GRID_WIDTH - 2; x++) {
			if (!grid[y][x] || processed[y][x]) continue;
			var type = grid[y][x].candyType;
			var matchLength = 1;
			var startX = x;
			while (x + matchLength < GRID_WIDTH && grid[y][x + matchLength] && grid[y][x + matchLength].candyType === type) {
				matchLength++;
			}
			if (matchLength >= 3) {
				for (var i = 0; i < matchLength; i++) {
					if (!processed[y][startX + i]) {
						matches.push(grid[y][startX + i]);
						processed[y][startX + i] = true;
					}
				}
			}
		}
	}
	// Find vertical matches
	for (var x = 0; x < GRID_WIDTH; x++) {
		for (var y = 0; y < GRID_HEIGHT - 2; y++) {
			if (!grid[y][x] || processed[y][x]) continue;
			var type = grid[y][x].candyType;
			var matchLength = 1;
			var startY = y;
			while (y + matchLength < GRID_HEIGHT && grid[y + matchLength][x] && grid[y + matchLength][x].candyType === type) {
				matchLength++;
			}
			if (matchLength >= 3) {
				for (var i = 0; i < matchLength; i++) {
					if (!processed[startY + i][x]) {
						matches.push(grid[startY + i][x]);
						processed[startY + i][x] = true;
					}
				}
			}
		}
	}
	return matches;
}
function createExplosionEffect(x, y) {
	// Create multiple particles for explosion effect
	var particleCount = 8 + Math.floor(Math.random() * 4);
	for (var i = 0; i < particleCount; i++) {
		var particle = LK.getAsset('explosion_particle', {
			anchorX: 0.5,
			anchorY: 0.5,
			x: x,
			y: y,
			scaleX: 0.8 + Math.random() * 0.4,
			scaleY: 0.8 + Math.random() * 0.4
		});
		game.addChild(particle);
		// Random direction and distance
		var angle = Math.PI * 2 * i / particleCount + (Math.random() - 0.5) * 0.5;
		var distance = 60 + Math.random() * 40;
		var targetX = x + Math.cos(angle) * distance;
		var targetY = y + Math.sin(angle) * distance;
		// Animate particle explosion
		tween(particle, {
			x: targetX,
			y: targetY,
			scaleX: 0,
			scaleY: 0,
			alpha: 0
		}, {
			duration: 400 + Math.random() * 200,
			easing: tween.easeOut,
			onFinish: function onFinish() {
				if (particle.parent) {
					particle.parent.removeChild(particle);
				}
			}
		});
	}
	// Create star particles for extra sparkle
	var starCount = 4 + Math.floor(Math.random() * 3);
	for (var j = 0; j < starCount; j++) {
		var star = LK.getAsset('explosion_star', {
			anchorX: 0.5,
			anchorY: 0.5,
			x: x + (Math.random() - 0.5) * 40,
			y: y + (Math.random() - 0.5) * 40,
			rotation: Math.random() * Math.PI * 2
		});
		game.addChild(star);
		// Animate star particles
		tween(star, {
			scaleX: 1.5,
			scaleY: 1.5,
			alpha: 0,
			rotation: star.rotation + Math.PI * 2
		}, {
			duration: 600,
			easing: tween.easeOut,
			onFinish: function onFinish() {
				if (star.parent) {
					star.parent.removeChild(star);
				}
			}
		});
	}
}
function clearMatches(matches) {
	if (matches.length === 0) return;
	// Play explosion sound for each candy cleared
	for (var i = 0; i < matches.length; i++) {
		LK.getSound('explosion').play();
	}
	LK.getSound('match').play();
	// Handle matches
	currentScore += matches.length * 50;
	scoreText.setText('Score: ' + currentScore);
	for (var i = 0; i < matches.length; i++) {
		var candy = matches[i];
		// Create explosion effect at candy position
		createExplosionEffect(candy.x, candy.y);
		grid[candy.gridY][candy.gridX] = null;
		candy.destroy();
		// Remove from candies array
		var index = candies.indexOf(candy);
		if (index > -1) {
			candies.splice(index, 1);
		}
	}
}
function applyGravity() {
	var moved = false;
	for (var x = 0; x < GRID_WIDTH; x++) {
		var writeY = GRID_HEIGHT - 1;
		for (var y = GRID_HEIGHT - 1; y >= 0; y--) {
			if (grid[y][x] && !grid[y][x].isMarkedForDestroy) {
				if (y !== writeY) {
					grid[writeY][x] = grid[y][x];
					grid[y][x] = null;
					grid[writeY][x].moveTo(x, writeY, 200);
					moved = true;
				}
				writeY--;
			}
		}
		// Fill empty spaces at top
		for (var emptyY = writeY; emptyY >= 0; emptyY--) {
			var newCandy = createCandy(x, emptyY, getRandomCandyType());
			newCandy.y = GRID_START_Y - (writeY - emptyY + 1) * CELL_SIZE + CELL_SIZE / 2;
			newCandy.moveTo(x, emptyY, 300);
			moved = true;
		}
	}
	return moved;
}
function areAdjacent(candy1, candy2) {
	var dx = Math.abs(candy1.gridX - candy2.gridX);
	var dy = Math.abs(candy1.gridY - candy2.gridY);
	return dx === 1 && dy === 0 || dx === 0 && dy === 1;
}
function swapCandies(candy1, candy2) {
	// Swap in grid
	grid[candy1.gridY][candy1.gridX] = candy2;
	grid[candy2.gridY][candy2.gridX] = candy1;
	// Swap positions
	var tempX = candy1.gridX;
	var tempY = candy1.gridY;
	candy1.moveTo(candy2.gridX, candy2.gridY, 200);
	candy2.moveTo(tempX, tempY, 200);
}
function processMatches() {
	if (isProcessing) return;
	isProcessing = true;
	LK.setTimeout(function () {
		var matches = findMatches();
		if (matches.length > 0) {
			clearMatches(matches);
			LK.setTimeout(function () {
				if (applyGravity()) {
					LK.setTimeout(function () {
						isProcessing = false;
						processMatches(); // Check for cascading matches
					}, 400);
				} else {
					isProcessing = false;
					checkGameState();
				}
			}, 300);
		} else {
			isProcessing = false;
			checkGameState();
		}
	}, 100);
}
function checkGameState() {
	if (currentScore >= targetScore) {
		completeLevel();
		return;
	}
	if (movesLeft <= 0) {
		LK.showGameOver();
		return;
	}
}
game.down = function (x, y, obj) {
	if (isProcessing) return;
	var gridX = Math.floor((x - GRID_START_X) / CELL_SIZE);
	var gridY = Math.floor((y - GRID_START_Y) / CELL_SIZE);
	if (gridX < 0 || gridX >= GRID_WIDTH || gridY < 0 || gridY >= GRID_HEIGHT) {
		selectedCandy = null;
		return;
	}
	var clickedCandy = grid[gridY][gridX];
	if (!clickedCandy || clickedCandy.isMoving) {
		selectedCandy = null;
		return;
	}
	// Start drag functionality
	draggedCandy = clickedCandy;
	isDragging = false;
	dragStartX = x;
	dragStartY = y;
	if (selectedCandy === null) {
		selectedCandy = clickedCandy;
		selectedCandy.scaleX = 1.1;
		selectedCandy.scaleY = 1.1;
	} else if (selectedCandy === clickedCandy) {
		selectedCandy.scaleX = 1.0;
		selectedCandy.scaleY = 1.0;
		selectedCandy = null;
	} else if (areAdjacent(selectedCandy, clickedCandy)) {
		selectedCandy.scaleX = 1.0;
		selectedCandy.scaleY = 1.0;
		// Try swap
		swapCandies(selectedCandy, clickedCandy);
		LK.getSound('swap').play();
		LK.setTimeout(function () {
			var matches = findMatches();
			if (matches.length > 0) {
				movesLeft--;
				movesText.setText('Moves: ' + movesLeft);
				processMatches();
			} else {
				// Swap back if no matches
				swapCandies(selectedCandy, clickedCandy);
			}
			selectedCandy = null;
		}, 250);
	} else {
		selectedCandy.scaleX = 1.0;
		selectedCandy.scaleY = 1.0;
		selectedCandy = clickedCandy;
		selectedCandy.scaleX = 1.1;
		selectedCandy.scaleY = 1.1;
	}
};
game.move = function (x, y, obj) {
	if (!draggedCandy || isProcessing) return;
	var dragDistance = Math.sqrt((x - dragStartX) * (x - dragStartX) + (y - dragStartY) * (y - dragStartY));
	if (dragDistance > 30 && !isDragging) {
		isDragging = true;
		// Scale up dragged candy for visual feedback
		tween(draggedCandy, {
			scaleX: 1.2,
			scaleY: 1.2
		}, {
			duration: 150,
			easing: tween.easeOut
		});
	}
	if (isDragging) {
		// Move candy with finger/mouse
		draggedCandy.x = GRID_START_X + draggedCandy.gridX * CELL_SIZE + CELL_SIZE / 2 + (x - dragStartX);
		draggedCandy.y = GRID_START_Y + draggedCandy.gridY * CELL_SIZE + CELL_SIZE / 2 + (y - dragStartY);
	}
};
game.up = function (x, y, obj) {
	if (!draggedCandy) return;
	if (isDragging) {
		// Reset candy visual state
		tween(draggedCandy, {
			scaleX: 1.0,
			scaleY: 1.0
		}, {
			duration: 150,
			easing: tween.easeOut
		});
		// Determine target grid position based on drag direction
		var deltaX = x - dragStartX;
		var deltaY = y - dragStartY;
		var targetGridX = draggedCandy.gridX;
		var targetGridY = draggedCandy.gridY;
		// Check drag direction and distance
		if (Math.abs(deltaX) > Math.abs(deltaY)) {
			// Horizontal drag
			if (Math.abs(deltaX) > 50) {
				if (deltaX > 0 && draggedCandy.gridX < GRID_WIDTH - 1) {
					targetGridX = draggedCandy.gridX + 1;
				} else if (deltaX < 0 && draggedCandy.gridX > 0) {
					targetGridX = draggedCandy.gridX - 1;
				}
			}
		} else {
			// Vertical drag
			if (Math.abs(deltaY) > 50) {
				if (deltaY > 0 && draggedCandy.gridY < GRID_HEIGHT - 1) {
					targetGridY = draggedCandy.gridY + 1;
				} else if (deltaY < 0 && draggedCandy.gridY > 0) {
					targetGridY = draggedCandy.gridY - 1;
				}
			}
		}
		// Reset candy position
		draggedCandy.x = GRID_START_X + draggedCandy.gridX * CELL_SIZE + CELL_SIZE / 2;
		draggedCandy.y = GRID_START_Y + draggedCandy.gridY * CELL_SIZE + CELL_SIZE / 2;
		// Perform swap if valid target
		if ((targetGridX !== draggedCandy.gridX || targetGridY !== draggedCandy.gridY) && targetGridX >= 0 && targetGridX < GRID_WIDTH && targetGridY >= 0 && targetGridY < GRID_HEIGHT) {
			var targetCandy = grid[targetGridY][targetGridX];
			if (targetCandy && !targetCandy.isMoving) {
				// Clear any previous selection
				if (selectedCandy) {
					selectedCandy.scaleX = 1.0;
					selectedCandy.scaleY = 1.0;
				}
				// Perform swap
				swapCandies(draggedCandy, targetCandy);
				LK.getSound('swap').play();
				LK.setTimeout(function () {
					var matches = findMatches();
					if (matches.length > 0) {
						movesLeft--;
						movesText.setText('Moves: ' + movesLeft);
						processMatches();
					} else {
						// Swap back if no matches
						swapCandies(draggedCandy, targetCandy);
					}
				}, 250);
			}
		}
	}
	// Reset drag state
	draggedCandy = null;
	isDragging = false;
	selectedCandy = null;
};
// Add decorative candy elements floating in background
var decorations = [];
for (var i = 0; i < 8; i++) {
	var decoration = LK.getAsset('candy_decoration', {
		anchorX: 0.5,
		anchorY: 0.5,
		x: Math.random() * 2048,
		y: Math.random() * 2732,
		scaleX: 0.5 + Math.random() * 0.5,
		scaleY: 0.5 + Math.random() * 0.5
	});
	decoration.alpha = 0.2 + Math.random() * 0.3;
	game.addChild(decoration);
	decorations.push(decoration);
	// Animate floating motion
	var animDuration = 3000 + Math.random() * 2000;
	var targetY = decoration.y + (Math.random() - 0.5) * 400;
	tween(decoration, {
		y: targetY,
		rotation: Math.random() * Math.PI * 2
	}, {
		duration: animDuration,
		easing: tween.easeInOut,
		onFinish: function onFinish() {
			// Restart animation
			var newTargetY = decoration.y + (Math.random() - 0.5) * 400;
			tween(decoration, {
				y: newTargetY,
				rotation: decoration.rotation + Math.PI * 2
			}, {
				duration: animDuration,
				easing: tween.easeInOut
			});
		}
	});
}
// Add sparkle effects
var sparkles = [];
for (var j = 0; j < 15; j++) {
	var sparkle = LK.getAsset('sparkle', {
		anchorX: 0.5,
		anchorY: 0.5,
		x: Math.random() * 2048,
		y: Math.random() * 2732,
		scaleX: 0.3 + Math.random() * 0.4,
		scaleY: 0.3 + Math.random() * 0.4
	});
	sparkle.alpha = 0.4 + Math.random() * 0.6;
	game.addChild(sparkle);
	sparkles.push(sparkle);
	// Twinkling animation
	var twinkleDuration = 1000 + Math.random() * 1500;
	tween(sparkle, {
		alpha: 0.1,
		scaleX: sparkle.scaleX * 0.5,
		scaleY: sparkle.scaleY * 0.5
	}, {
		duration: twinkleDuration,
		easing: tween.easeInOut,
		onFinish: function onFinish() {
			tween(sparkle, {
				alpha: 0.4 + Math.random() * 0.6,
				scaleX: 0.3 + Math.random() * 0.4,
				scaleY: 0.3 + Math.random() * 0.4
			}, {
				duration: twinkleDuration,
				easing: tween.easeInOut
			});
		}
	});
}
// Initialize the game
loadProgress();
initializeLevel();

===================================================================
--- original.js
+++ change.js
@@ -772,10 +772,13 @@
 	}
 }
 function clearMatches(matches) {
 	if (matches.length === 0) return;
+	// Play explosion sound for each candy cleared
+	for (var i = 0; i < matches.length; i++) {
+		LK.getSound('explosion').play();
+	}
 	LK.getSound('match').play();
-	LK.getSound('explosion').play();
 	// Handle matches
 	currentScore += matches.length * 50;
 	scoreText.setText('Score: ' + currentScore);
 	for (var i = 0; i < matches.length; i++) {