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

/**** 
* Classes
****/ 
var Bomb = Container.expand(function () {
	var self = Container.call(this);
	self.gridX = 0;
	self.gridY = 0;
	self.isAnimating = false;
	var bombGraphics = self.attachAsset('bomb', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Add gentle swaying animation
	self.startSwayAnimation = function () {
		var swayAmount = 0.1; // More pronounced sway than candies
		var swayDuration = 600 + Math.random() * 300; // Faster sway
		function swayLeft() {
			tween(bombGraphics, {
				rotation: -swayAmount
			}, {
				duration: swayDuration,
				easing: tween.easeInOut,
				onFinish: swayRight
			});
		}
		function swayRight() {
			tween(bombGraphics, {
				rotation: swayAmount
			}, {
				duration: swayDuration,
				easing: tween.easeInOut,
				onFinish: swayLeft
			});
		}
		// Start with random direction and slight delay for variety
		LK.setTimeout(function () {
			if (Math.random() > 0.5) {
				swayLeft();
			} else {
				swayRight();
			}
		}, Math.random() * 250);
	};
	// Start swaying animation
	self.startSwayAnimation();
	self.setGridPosition = function (gridX, gridY) {
		self.gridX = gridX;
		self.gridY = gridY;
		self.x = GRID_START_X + gridX * CELL_SIZE + CELL_SIZE / 2;
		self.y = GRID_START_Y + gridY * CELL_SIZE + CELL_SIZE / 2;
	};
	self.animateToPosition = function (targetX, targetY, duration, onComplete) {
		self.isAnimating = true;
		tween(self, {
			x: targetX,
			y: targetY
		}, {
			duration: duration || 300,
			easing: tween.easeOut,
			onFinish: function onFinish() {
				self.isAnimating = false;
				if (onComplete) onComplete();
			}
		});
	};
	self.explode = function () {
		// Stop swaying animation
		tween.stop(bombGraphics);
		tween(self, {
			scaleX: 2.5,
			scaleY: 2.5,
			alpha: 0
		}, {
			duration: 400,
			easing: tween.easeOut,
			onFinish: function onFinish() {
				self.destroy();
			}
		});
	};
	return self;
});
var Candy = Container.expand(function (candyType) {
	var self = Container.call(this);
	self.candyType = candyType;
	self.gridX = 0;
	self.gridY = 0;
	self.isAnimating = false;
	var candyAssets = [];
	if (currentTheme === 'classic') {
		candyAssets = ['classic_candy_red', 'classic_candy_blue', 'classic_candy_green', 'classic_candy_purple', 'classic_candy_orange'];
	} else {
		candyAssets = ['candy_red', 'candy_blue', 'candy_green', 'candy_yellow', 'candy_purple', 'candy_orange'];
	}
	var candyGraphics = self.attachAsset(candyAssets[candyType], {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Add gentle swaying animation
	self.startSwayAnimation = function () {
		var swayAmount = 0.05; // Small rotation amount
		var swayDuration = 1000 + Math.random() * 500; // 1-1.5 seconds for variety (2x faster)
		function swayLeft() {
			tween(candyGraphics, {
				rotation: -swayAmount
			}, {
				duration: swayDuration,
				easing: tween.easeInOut,
				onFinish: swayRight
			});
		}
		function swayRight() {
			tween(candyGraphics, {
				rotation: swayAmount
			}, {
				duration: swayDuration,
				easing: tween.easeInOut,
				onFinish: swayLeft
			});
		}
		// Start with random direction and slight delay for variety
		LK.setTimeout(function () {
			if (Math.random() > 0.5) {
				swayLeft();
			} else {
				swayRight();
			}
		}, Math.random() * 250);
	};
	// Start swaying animation
	self.startSwayAnimation();
	self.setGridPosition = function (gridX, gridY) {
		self.gridX = gridX;
		self.gridY = gridY;
		self.x = GRID_START_X + gridX * CELL_SIZE + CELL_SIZE / 2;
		self.y = GRID_START_Y + gridY * CELL_SIZE + CELL_SIZE / 2;
	};
	self.animateToPosition = function (targetX, targetY, duration, onComplete) {
		self.isAnimating = true;
		tween(self, {
			x: targetX,
			y: targetY
		}, {
			duration: duration || 300,
			easing: tween.easeOut,
			onFinish: function onFinish() {
				self.isAnimating = false;
				if (onComplete) onComplete();
			}
		});
	};
	self.explode = function () {
		// Stop swaying animation
		tween.stop(candyGraphics);
		tween(self, {
			scaleX: 1.5,
			scaleY: 1.5,
			alpha: 0
		}, {
			duration: 200,
			easing: tween.easeOut,
			onFinish: function onFinish() {
				self.destroy();
			}
		});
	};
	return self;
});
var Firecracker = Container.expand(function () {
	var self = Container.call(this);
	self.gridX = 0;
	self.gridY = 0;
	self.isAnimating = false;
	var firecrackerGraphics = self.attachAsset('firecracker', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Add gentle swaying animation
	self.startSwayAnimation = function () {
		var swayAmount = 0.08; // Slightly more sway than candies
		var swayDuration = 800 + Math.random() * 400; // Faster sway
		function swayLeft() {
			tween(firecrackerGraphics, {
				rotation: -swayAmount
			}, {
				duration: swayDuration,
				easing: tween.easeInOut,
				onFinish: swayRight
			});
		}
		function swayRight() {
			tween(firecrackerGraphics, {
				rotation: swayAmount
			}, {
				duration: swayDuration,
				easing: tween.easeInOut,
				onFinish: swayLeft
			});
		}
		// Start with random direction and slight delay for variety
		LK.setTimeout(function () {
			if (Math.random() > 0.5) {
				swayLeft();
			} else {
				swayRight();
			}
		}, Math.random() * 250);
	};
	// Start swaying animation
	self.startSwayAnimation();
	self.setGridPosition = function (gridX, gridY) {
		self.gridX = gridX;
		self.gridY = gridY;
		self.x = GRID_START_X + gridX * CELL_SIZE + CELL_SIZE / 2;
		self.y = GRID_START_Y + gridY * CELL_SIZE + CELL_SIZE / 2;
	};
	self.animateToPosition = function (targetX, targetY, duration, onComplete) {
		self.isAnimating = true;
		tween(self, {
			x: targetX,
			y: targetY
		}, {
			duration: duration || 300,
			easing: tween.easeOut,
			onFinish: function onFinish() {
				self.isAnimating = false;
				if (onComplete) onComplete();
			}
		});
	};
	self.explode = function () {
		// Stop swaying animation
		tween.stop(firecrackerGraphics);
		tween(self, {
			scaleX: 2,
			scaleY: 2,
			alpha: 0
		}, {
			duration: 300,
			easing: tween.easeOut,
			onFinish: function onFinish() {
				self.destroy();
			}
		});
	};
	return self;
});
var Grid = Container.expand(function () {
	var self = Container.call(this);
	self.cells = [];
	self.candies = [];
	self.walls = [];
	// Create grid cells
	for (var y = 0; y < GRID_SIZE; y++) {
		self.cells[y] = [];
		self.candies[y] = [];
		self.walls[y] = [];
		for (var x = 0; x < GRID_SIZE; x++) {
			var cell = self.attachAsset('gridCell', {
				anchorX: 0.5,
				anchorY: 0.5,
				x: GRID_START_X + x * CELL_SIZE + CELL_SIZE / 2,
				y: GRID_START_Y + y * CELL_SIZE + CELL_SIZE / 2
			});
			self.cells[y][x] = cell;
			self.candies[y][x] = null;
			self.walls[y][x] = null;
		}
	}
	// Place exactly one wall per move
	self.placeWalls = function () {
		var wallCount = 1; // Always spawn exactly one wall
		var placedWalls = 0;
		var attempts = 0;
		var maxAttempts = 500;
		// Define border areas for wall placement
		var borderAreas = [
		// Top border
		{
			minX: 1,
			maxX: GRID_SIZE - 2,
			minY: 1,
			maxY: 2
		},
		// Bottom border
		{
			minX: 1,
			maxX: GRID_SIZE - 2,
			minY: GRID_SIZE - 3,
			maxY: GRID_SIZE - 2
		},
		// Left border
		{
			minX: 1,
			maxX: 2,
			minY: 1,
			maxY: GRID_SIZE - 2
		},
		// Right border
		{
			minX: GRID_SIZE - 3,
			maxX: GRID_SIZE - 2,
			minY: 1,
			maxY: GRID_SIZE - 2
		}];
		// Choose a random border area to place wall
		var chosenArea = borderAreas[Math.floor(Math.random() * borderAreas.length)];
		while (placedWalls < wallCount && attempts < maxAttempts) {
			var x = Math.floor(Math.random() * (chosenArea.maxX - chosenArea.minX + 1)) + chosenArea.minX;
			var y = Math.floor(Math.random() * (chosenArea.maxY - chosenArea.minY + 1)) + chosenArea.minY;
			attempts++;
			// Don't place walls if already occupied
			if (!self.walls[y][x]) {
				// Clear any candy at this position before placing wall
				if (self.candies[y][x]) {
					self.candies[y][x].destroy();
					self.candies[y][x] = null;
				}
				var wall = new Wall();
				wall.setGridPosition(x, y);
				self.walls[y][x] = wall;
				self.addChild(wall);
				placedWalls++;
			}
		}
	};
	self.fillGrid = function () {
		for (var y = 0; y < GRID_SIZE; y++) {
			for (var x = 0; x < GRID_SIZE; x++) {
				if (!self.candies[y][x] && !self.walls[y][x]) {
					// 1% chance to spawn bomb
					if (Math.random() < 0.01) {
						var bomb = new Bomb();
						bomb.setGridPosition(x, y);
						self.candies[y][x] = bomb;
						self.addChild(bomb);
					} else if (Math.random() < 0.001) {
						var superBomb = new SuperBomb();
						superBomb.setGridPosition(x, y);
						self.candies[y][x] = superBomb;
						self.addChild(superBomb);
					} else if (Math.random() < 0.02) {
						var firecracker = new Firecracker();
						firecracker.setGridPosition(x, y);
						self.candies[y][x] = firecracker;
						self.addChild(firecracker);
					} else {
						var candyType;
						var attempts = 0;
						// Try to find a candy type that doesn't create immediate matches
						do {
							if (currentTheme === 'classic') {
								candyType = Math.floor(Math.random() * 5);
							} else {
								candyType = Math.floor(Math.random() * 6);
							}
							attempts++;
						} while (attempts < 10 && self.wouldCreateMatch(x, y, candyType));
						var candy = new Candy(candyType);
						candy.setGridPosition(x, y);
						self.candies[y][x] = candy;
						self.addChild(candy);
					}
				}
			}
		}
	};
	self.findMatches = function () {
		var matches = [];
		// Check horizontal matches
		for (var y = 0; y < GRID_SIZE; y++) {
			var count = 1;
			var currentType = self.candies[y][0] ? self.candies[y][0].candyType : -1;
			for (var x = 1; x < GRID_SIZE; x++) {
				var candyType = self.candies[y][x] ? self.candies[y][x].candyType : -1;
				if (candyType === currentType && candyType !== -1) {
					count++;
				} else {
					if (count >= 3) {
						for (var i = x - count; i < x; i++) {
							matches.push({
								x: i,
								y: y
							});
						}
					}
					count = 1;
					currentType = candyType;
				}
			}
			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 = self.candies[0][x] ? self.candies[0][x].candyType : -1;
			for (var y = 1; y < GRID_SIZE; y++) {
				var candyType = self.candies[y][x] ? self.candies[y][x].candyType : -1;
				if (candyType === currentType && candyType !== -1) {
					count++;
				} else {
					if (count >= 3) {
						for (var i = y - count; i < y; i++) {
							matches.push({
								x: x,
								y: i
							});
						}
					}
					count = 1;
					currentType = candyType;
				}
			}
			if (count >= 3) {
				for (var i = GRID_SIZE - count; i < GRID_SIZE; i++) {
					matches.push({
						x: x,
						y: i
					});
				}
			}
		}
		return matches;
	};
	self.removeMatches = function (matches) {
		var score = 0;
		for (var i = 0; i < matches.length; i++) {
			var match = matches[i];
			if (self.candies[match.y][match.x]) {
				self.candies[match.y][match.x].explode();
				self.candies[match.y][match.x] = null;
				score += 10;
			}
		}
		return score;
	};
	self.explodeRow = function (rowY) {
		var score = 0;
		LK.getSound('firecracker_explode').play();
		// Destroy entire row including walls
		for (var x = 0; x < GRID_SIZE; x++) {
			// Destroy candy if present
			if (self.candies[rowY][x]) {
				self.candies[rowY][x].explode();
				self.candies[rowY][x] = null;
				score += 25;
			}
			// Destroy wall if present
			if (self.walls[rowY][x]) {
				self.walls[rowY][x].destroy();
				self.walls[rowY][x] = null;
				score += 15; // Give points for destroying walls
			}
		}
		return score;
	};
	self.explodeBomb = function (centerX, centerY) {
		var score = 0;
		LK.getSound('bomb_explode').play();
		// Explode 3x3 area around the bomb
		for (var dx = -1; dx <= 1; dx++) {
			for (var dy = -1; dy <= 1; dy++) {
				var x = centerX + dx;
				var y = centerY + dy;
				// Check bounds
				if (x >= 0 && x < GRID_SIZE && y >= 0 && y < GRID_SIZE) {
					// Destroy candy if present
					if (self.candies[y][x]) {
						self.candies[y][x].explode();
						self.candies[y][x] = null;
						score += 20; // More points for bomb explosion
					}
					// Destroy wall if present
					if (self.walls[y][x]) {
						self.walls[y][x].destroy();
						self.walls[y][x] = null;
						score += 15; // Give points for destroying walls
					}
				}
			}
		}
		return score;
	};
	self.explodeSuperBomb = function (centerX, centerY) {
		var score = 0;
		LK.getSound('super_bomb_explode').play();
		// Explode entire 10x10 area
		for (var x = 0; x < GRID_SIZE; x++) {
			for (var y = 0; y < GRID_SIZE; y++) {
				// Destroy candy if present
				if (self.candies[y][x]) {
					self.candies[y][x].explode();
					self.candies[y][x] = null;
				}
				// Destroy wall if present
				if (self.walls[y][x]) {
					self.walls[y][x].destroy();
					self.walls[y][x] = null;
				}
			}
		}
		return score;
	};
	self.applyGravity = function () {
		var moved = false;
		for (var x = 0; x < GRID_SIZE; x++) {
			for (var y = GRID_SIZE - 1; y >= 0; y--) {
				if (!self.candies[y][x] && !self.walls[y][x]) {
					// Find candy above to fall down
					for (var aboveY = y - 1; aboveY >= 0; aboveY--) {
						if (self.candies[aboveY][x]) {
							self.candies[y][x] = self.candies[aboveY][x];
							self.candies[aboveY][x] = null;
							self.candies[y][x].gridX = x;
							self.candies[y][x].gridY = y;
							var targetX = GRID_START_X + x * CELL_SIZE + CELL_SIZE / 2;
							var targetY = GRID_START_Y + y * CELL_SIZE + CELL_SIZE / 2;
							self.candies[y][x].animateToPosition(targetX, targetY, 300);
							moved = true;
							break;
						}
					}
				}
			}
		}
		return moved;
	};
	self.spawnNewCandies = function () {
		for (var x = 0; x < GRID_SIZE; x++) {
			for (var y = 0; y < GRID_SIZE; y++) {
				if (!self.candies[y][x] && !self.walls[y][x]) {
					// 1% chance to spawn bomb
					if (Math.random() < 0.01) {
						var bomb = new Bomb();
						bomb.x = GRID_START_X + x * CELL_SIZE + CELL_SIZE / 2;
						bomb.y = GRID_START_Y - CELL_SIZE;
						bomb.gridX = x;
						bomb.gridY = y;
						self.candies[y][x] = bomb;
						self.addChild(bomb);
						var targetY = GRID_START_Y + y * CELL_SIZE + CELL_SIZE / 2;
						bomb.animateToPosition(bomb.x, targetY, 400);
					} else if (Math.random() < 0.001) {
						var superBomb = new SuperBomb();
						superBomb.x = GRID_START_X + x * CELL_SIZE + CELL_SIZE / 2;
						superBomb.y = GRID_START_Y - CELL_SIZE;
						superBomb.gridX = x;
						superBomb.gridY = y;
						self.candies[y][x] = superBomb;
						self.addChild(superBomb);
						var targetY = GRID_START_Y + y * CELL_SIZE + CELL_SIZE / 2;
						superBomb.animateToPosition(superBomb.x, targetY, 400);
					} else if (Math.random() < 0.02) {
						var firecracker = new Firecracker();
						firecracker.x = GRID_START_X + x * CELL_SIZE + CELL_SIZE / 2;
						firecracker.y = GRID_START_Y - CELL_SIZE;
						firecracker.gridX = x;
						firecracker.gridY = y;
						self.candies[y][x] = firecracker;
						self.addChild(firecracker);
						var targetY = GRID_START_Y + y * CELL_SIZE + CELL_SIZE / 2;
						firecracker.animateToPosition(firecracker.x, targetY, 400);
					} else {
						var candyType;
						if (currentTheme === 'classic') {
							candyType = Math.floor(Math.random() * 5);
						} else {
							candyType = Math.floor(Math.random() * 6);
						}
						var candy = new Candy(candyType);
						candy.x = GRID_START_X + x * CELL_SIZE + CELL_SIZE / 2;
						candy.y = GRID_START_Y - CELL_SIZE;
						candy.gridX = x;
						candy.gridY = y;
						self.candies[y][x] = candy;
						self.addChild(candy);
						var targetY = GRID_START_Y + y * CELL_SIZE + CELL_SIZE / 2;
						candy.animateToPosition(candy.x, targetY, 400);
					}
				}
			}
		}
	};
	self.swapCandies = function (x1, y1, x2, y2) {
		var candy1 = self.candies[y1][x1];
		var candy2 = self.candies[y2][x2];
		if (!candy1 || !candy2) return false;
		// Swap in grid
		self.candies[y1][x1] = candy2;
		self.candies[y2][x2] = candy1;
		// Update grid positions
		candy1.gridX = x2;
		candy1.gridY = y2;
		candy2.gridX = x1;
		candy2.gridY = y1;
		// Animate to new positions
		var pos1X = GRID_START_X + x2 * CELL_SIZE + CELL_SIZE / 2;
		var pos1Y = GRID_START_Y + y2 * CELL_SIZE + CELL_SIZE / 2;
		var pos2X = GRID_START_X + x1 * CELL_SIZE + CELL_SIZE / 2;
		var pos2Y = GRID_START_Y + y1 * CELL_SIZE + CELL_SIZE / 2;
		candy1.animateToPosition(pos1X, pos1Y, 200);
		candy2.animateToPosition(pos2X, pos2Y, 200);
		return true;
	};
	self.getCandyAt = function (x, y) {
		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_SIZE && gridY >= 0 && gridY < GRID_SIZE) {
			// Don't return candy info if there's a wall
			if (self.walls[gridY][gridX]) return null;
			return {
				x: gridX,
				y: gridY,
				candy: self.candies[gridY][gridX]
			};
		}
		return null;
	};
	self.wouldCreateMatch = function (x, y, candyType) {
		// Check horizontal match potential
		var horizontalCount = 1;
		// Check left
		for (var i = x - 1; i >= 0 && self.candies[y][i] && self.candies[y][i].candyType === candyType; i--) {
			horizontalCount++;
		}
		// Check right
		for (var i = x + 1; i < GRID_SIZE && self.candies[y][i] && self.candies[y][i].candyType === candyType; i++) {
			horizontalCount++;
		}
		if (horizontalCount >= 3) return true;
		// Check vertical match potential
		var verticalCount = 1;
		// Check up
		for (var i = y - 1; i >= 0 && self.candies[i][x] && self.candies[i][x].candyType === candyType; i--) {
			verticalCount++;
		}
		// Check down
		for (var i = y + 1; i < GRID_SIZE && self.candies[i][x] && self.candies[i][x].candyType === candyType; i++) {
			verticalCount++;
		}
		if (verticalCount >= 3) return true;
		return false;
	};
	return self;
});
var MainMenu = Container.expand(function () {
	var self = Container.call(this);
	var title = new Text2('Guna Blast', {
		size: 180,
		fill: 0xFFFF00
	});
	title.anchor.set(0.5, 0.5);
	title.x = 1024;
	title.y = 400;
	self.addChild(title);
	var startButton = new MenuButton('BAŞLA', function () {
		showThemeSelection();
	});
	startButton.x = 1024;
	startButton.y = 800;
	self.addChild(startButton);
	var themeButton = new MenuButton('TEMA', function () {
		showThemeSelection();
	});
	themeButton.x = 1024;
	themeButton.y = 1200;
	self.addChild(themeButton);
	var resetThemeButton = new MenuButton('TEMA RESET', function () {
		// Reset to classic theme
		storage.theme = 'classic';
		storage.unlockedThemes = ['classic'];
		currentTheme = 'classic';
		unlockedThemes = ['classic'];
	});
	resetThemeButton.x = 1024;
	resetThemeButton.y = 1600;
	self.addChild(resetThemeButton);
	return self;
});
var MenuButton = Container.expand(function (text, onClick) {
	var self = Container.call(this);
	var background = self.attachAsset('button_bg', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	var buttonText = new Text2(text, {
		size: 80,
		fill: 0x000000
	});
	buttonText.anchor.set(0.5, 0.5);
	self.addChild(buttonText);
	self.down = function (x, y, obj) {
		if (onClick) onClick();
	};
	return self;
});
var SuperBomb = Container.expand(function () {
	var self = Container.call(this);
	self.gridX = 0;
	self.gridY = 0;
	self.isAnimating = false;
	var superBombGraphics = self.attachAsset('super_bomb', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Add more pronounced swaying animation
	self.startSwayAnimation = function () {
		var swayAmount = 0.15; // More pronounced sway than regular bomb
		var swayDuration = 500 + Math.random() * 200; // Faster sway
		function swayLeft() {
			tween(superBombGraphics, {
				rotation: -swayAmount
			}, {
				duration: swayDuration,
				easing: tween.easeInOut,
				onFinish: swayRight
			});
		}
		function swayRight() {
			tween(superBombGraphics, {
				rotation: swayAmount
			}, {
				duration: swayDuration,
				easing: tween.easeInOut,
				onFinish: swayLeft
			});
		}
		// Start with random direction and slight delay for variety
		LK.setTimeout(function () {
			if (Math.random() > 0.5) {
				swayLeft();
			} else {
				swayRight();
			}
		}, Math.random() * 250);
	};
	// Start swaying animation
	self.startSwayAnimation();
	self.setGridPosition = function (gridX, gridY) {
		self.gridX = gridX;
		self.gridY = gridY;
		self.x = GRID_START_X + gridX * CELL_SIZE + CELL_SIZE / 2;
		self.y = GRID_START_Y + gridY * CELL_SIZE + CELL_SIZE / 2;
	};
	self.animateToPosition = function (targetX, targetY, duration, onComplete) {
		self.isAnimating = true;
		tween(self, {
			x: targetX,
			y: targetY
		}, {
			duration: duration || 300,
			easing: tween.easeOut,
			onFinish: function onFinish() {
				self.isAnimating = false;
				if (onComplete) onComplete();
			}
		});
	};
	self.explode = function () {
		// Stop swaying animation
		tween.stop(superBombGraphics);
		tween(self, {
			scaleX: 3.5,
			scaleY: 3.5,
			alpha: 0
		}, {
			duration: 600,
			easing: tween.easeOut,
			onFinish: function onFinish() {
				self.destroy();
			}
		});
	};
	return self;
});
var ThemeSelection = Container.expand(function () {
	var self = Container.call(this);
	var title = new Text2('Tema Seç', {
		size: 140,
		fill: 0xFFFFFF
	});
	title.anchor.set(0.5, 0.5);
	title.x = 1024;
	title.y = 400;
	self.addChild(title);
	var classicButton = new MenuButton('KLASİK', function () {
		setTheme('classic');
		startGame();
	});
	classicButton.x = 1024;
	classicButton.y = 700;
	self.addChild(classicButton);
	var darkButtonText = unlockedThemes.indexOf('dark') !== -1 ? 'Fast Food' : 'Fast Food (Kilitli)';
	var darkButton = new MenuButton(darkButtonText, function () {
		if (unlockedThemes.indexOf('dark') !== -1) {
			setTheme('dark');
			startGame();
		} else {
			// Show message that theme is locked
			var lockedMessage = new Text2('Bu temayı açmak için klasik temayı kazanın!', {
				size: 40,
				fill: 0xFF0000
			});
			lockedMessage.anchor.set(0.5, 0.5);
			lockedMessage.x = 1024;
			lockedMessage.y = 1400;
			self.addChild(lockedMessage);
			LK.setTimeout(function () {
				lockedMessage.destroy();
			}, 2000);
		}
	});
	darkButton.x = 1024;
	darkButton.y = 1100;
	self.addChild(darkButton);
	return self;
});
var Wall = Container.expand(function () {
	var self = Container.call(this);
	self.gridX = 0;
	self.gridY = 0;
	var wallGraphics = self.attachAsset('wall', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.setGridPosition = function (gridX, gridY) {
		self.gridX = gridX;
		self.gridY = gridY;
		self.x = GRID_START_X + gridX * CELL_SIZE + CELL_SIZE / 2;
		self.y = GRID_START_Y + gridY * CELL_SIZE + CELL_SIZE / 2;
	};
	return self;
});

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

/**** 
* Game Code
****/ 
var GRID_SIZE = 10;
var CELL_SIZE = 200;
var GRID_START_X = (2048 - GRID_SIZE * CELL_SIZE) / 2;
var GRID_START_Y = 600;
var MAX_MOVES = 30;
var currentScore = 0;
var movesLeft = MAX_MOVES;
var highScore = storage.highScore || 0;
var gameState = 'menu'; // 'menu', 'playing', 'processing', 'gameover'
var selectedCandy = null;
var grid = null;
var isProcessing = false;
var currentTheme = storage.theme || 'classic';
var unlockedThemes = storage.unlockedThemes || ['classic'];
var mainMenu = null;
var themeSelection = null;
var gameUI = null;
// UI Elements (will be created when game starts)
var scoreText = null;
var movesText = null;
// Show main menu on start
showMainMenu();
function processMatches() {
	if (isProcessing) return; // Prevent multiple simultaneous processing
	isProcessing = true;
	var matches = grid.findMatches();
	if (matches.length > 0) {
		var points = grid.removeMatches(matches);
		currentScore += points;
		if (scoreText) scoreText.setText('Score: ' + currentScore);
		LK.getSound('match').play();
		LK.setTimeout(function () {
			if (!grid || gameState !== 'playing') {
				isProcessing = false;
				return;
			}
			var moved = grid.applyGravity();
			LK.setTimeout(function () {
				if (!grid || gameState !== 'playing') {
					isProcessing = false;
					return;
				}
				grid.spawnNewCandies();
				LK.setTimeout(function () {
					if (!grid || gameState !== 'playing') {
						isProcessing = false;
						return;
					}
					isProcessing = false; // Reset before recursive call
					processMatches(); // Check for chain reactions
				}, 500);
			}, 300);
		}, 300);
	} else {
		isProcessing = false;
		checkGameState();
	}
}
function checkGameState() {
	if (movesLeft <= 0) {
		// Check if current score is a new high score
		if (currentScore > highScore) {
			highScore = currentScore;
			storage.highScore = highScore;
		}
		// If player reaches 1000+ points with classic theme, unlock Fast Food theme
		if (currentScore >= 1000 && currentTheme === 'classic' && unlockedThemes.indexOf('dark') === -1) {
			unlockedThemes.push('dark');
			storage.unlockedThemes = unlockedThemes;
		}
		LK.showGameOver();
	}
}
function setTheme(theme) {
	currentTheme = theme;
	storage.theme = theme;
	updateThemeColors();
}
function updateThemeColors() {
	if (currentTheme === 'dark') {
		game.setBackgroundColor(0x111111);
	} else {
		game.setBackgroundColor(0x2c1810);
	}
}
function showMainMenu() {
	gameState = 'menu';
	if (grid) {
		grid.destroy();
		grid = null;
	}
	if (gameUI) {
		gameUI.destroy();
		gameUI = null;
	}
	if (themeSelection) {
		themeSelection.destroy();
		themeSelection = null;
	}
	mainMenu = game.addChild(new MainMenu());
}
function showThemeSelection() {
	if (mainMenu) {
		mainMenu.destroy();
		mainMenu = null;
	}
	themeSelection = game.addChild(new ThemeSelection());
}
function startGame() {
	gameState = 'playing';
	currentScore = 0;
	movesLeft = MAX_MOVES;
	selectedCandy = null;
	isProcessing = false;
	if (mainMenu) {
		mainMenu.destroy();
		mainMenu = null;
	}
	if (themeSelection) {
		themeSelection.destroy();
		themeSelection = null;
	}
	updateThemeColors();
	initializeGameUI();
	grid = game.addChild(new Grid());
	grid.placeWalls();
	grid.fillGrid();
	LK.setTimeout(function () {
		processMatches();
	}, 500);
}
function initializeGameUI() {
	gameUI = new Container();
	game.addChild(gameUI);
	scoreText = new Text2('Score: 0', {
		size: 60,
		fill: 0xFFFFFF
	});
	scoreText.anchor.set(0.5, 0);
	LK.gui.top.addChild(scoreText);
	movesText = new Text2('Moves: ' + MAX_MOVES, {
		size: 60,
		fill: 0xFFFFFF
	});
	movesText.anchor.set(0.5, 0);
	movesText.y = 80;
	LK.gui.top.addChild(movesText);
	var highScoreText = new Text2('High Score: ' + highScore, {
		size: 50,
		fill: 0xFFFF00
	});
	highScoreText.anchor.set(0.5, 0);
	highScoreText.y = 150;
	LK.gui.top.addChild(highScoreText);
}
function isAdjacent(x1, y1, x2, y2) {
	var dx = Math.abs(x1 - x2);
	var dy = Math.abs(y1 - y2);
	return dx === 1 && dy === 0 || dx === 0 && dy === 1;
}
var dragStartCandy = null;
var dragStartPos = null;
game.down = function (x, y, obj) {
	if (gameState !== 'playing' || isProcessing) return;
	var candyInfo = grid.getCandyAt(x, y);
	if (candyInfo && candyInfo.candy) {
		// Check if it's a bomb
		if (candyInfo.candy.constructor === Bomb) {
			// Explode 3x3 area
			var points = grid.explodeBomb(candyInfo.x, candyInfo.y);
			currentScore += points;
			if (scoreText) scoreText.setText('Score: ' + currentScore);
			movesLeft--;
			movesText.setText('Moves: ' + movesLeft);
			// Add one wall after each move
			grid.placeWalls();
			// Process gravity and spawn new candies after explosion
			LK.setTimeout(function () {
				var moved = grid.applyGravity();
				LK.setTimeout(function () {
					grid.spawnNewCandies();
					LK.setTimeout(function () {
						processMatches();
					}, 500);
				}, 300);
			}, 300);
			return;
		}
		// Check if it's a super bomb
		if (candyInfo.candy.constructor === SuperBomb) {
			// Explode entire 10x10 area
			grid.explodeSuperBomb(candyInfo.x, candyInfo.y);
			movesLeft--;
			movesText.setText('Moves: ' + movesLeft);
			// Add one wall after each move
			grid.placeWalls();
			// Process gravity and spawn new candies after explosion
			LK.setTimeout(function () {
				var moved = grid.applyGravity();
				LK.setTimeout(function () {
					grid.spawnNewCandies();
					LK.setTimeout(function () {
						processMatches();
					}, 500);
				}, 300);
			}, 300);
			return;
		}
		// Check if it's a firecracker
		if (candyInfo.candy.constructor === Firecracker) {
			// Explode entire row
			var firecrackerRow = candyInfo.y;
			var points = grid.explodeRow(firecrackerRow);
			currentScore += points;
			if (scoreText) scoreText.setText('Score: ' + currentScore);
			movesLeft--;
			movesText.setText('Moves: ' + movesLeft);
			// Add one wall after each move
			grid.placeWalls();
			// Process gravity and spawn new candies after explosion
			LK.setTimeout(function () {
				var moved = grid.applyGravity();
				LK.setTimeout(function () {
					grid.spawnNewCandies();
					LK.setTimeout(function () {
						processMatches();
					}, 500);
				}, 300);
			}, 300);
			return;
		}
		// Start drag for regular candies
		dragStartCandy = candyInfo;
		dragStartPos = {
			x: x,
			y: y
		};
		// Scale up the candy to show it's being dragged
		candyInfo.candy.scaleX = 1.1;
		candyInfo.candy.scaleY = 1.1;
	}
};
game.move = function (x, y, obj) {
	if (gameState !== 'playing' || isProcessing || !dragStartCandy) return;
	// Calculate drag distance
	var dx = x - dragStartPos.x;
	var dy = y - dragStartPos.y;
	var distance = Math.sqrt(dx * dx + dy * dy);
	// If dragged far enough, determine direction and target
	if (distance > CELL_SIZE / 3) {
		var targetX = dragStartCandy.x;
		var targetY = dragStartCandy.y;
		// Determine primary drag direction
		if (Math.abs(dx) > Math.abs(dy)) {
			// Horizontal drag
			if (dx > 0) {
				targetX = dragStartCandy.x + 1; // Right
			} else {
				targetX = dragStartCandy.x - 1; // Left
			}
		} else {
			// Vertical drag
			if (dy > 0) {
				targetY = dragStartCandy.y + 1; // Down
			} else {
				targetY = dragStartCandy.y - 1; // Up
			}
		}
		// Check if target position is valid and has a candy
		if (targetX >= 0 && targetX < GRID_SIZE && targetY >= 0 && targetY < GRID_SIZE) {
			var targetCandyInfo = {
				x: targetX,
				y: targetY,
				candy: grid.candies[targetY][targetX]
			};
			if (targetCandyInfo.candy && !grid.walls[targetY][targetX]) {
				// Perform the swap
				performCandySwap(dragStartCandy, targetCandyInfo);
				// Reset drag state
				dragStartCandy.candy.scaleX = 1;
				dragStartCandy.candy.scaleY = 1;
				dragStartCandy = null;
				dragStartPos = null;
			}
		}
	}
};
game.up = function (x, y, obj) {
	if (dragStartCandy) {
		// Reset candy scale and clear drag state
		dragStartCandy.candy.scaleX = 1;
		dragStartCandy.candy.scaleY = 1;
		dragStartCandy = null;
		dragStartPos = null;
	}
};
function performCandySwap(candyInfo1, candyInfo2) {
	// Try the swap
	grid.swapCandies(candyInfo1.x, candyInfo1.y, candyInfo2.x, candyInfo2.y);
	LK.getSound('swap').play();
	// Check if swap creates matches
	LK.setTimeout(function () {
		var matches = grid.findMatches();
		if (matches.length > 0) {
			movesLeft--;
			movesText.setText('Moves: ' + movesLeft);
			// Add one wall after each move
			grid.placeWalls();
			processMatches();
		} else {
			// Swap back if no matches and deduct a move
			grid.swapCandies(candyInfo2.x, candyInfo2.y, candyInfo1.x, candyInfo1.y);
			movesLeft--;
			movesText.setText('Moves: ' + movesLeft);
			// Add one wall after each move
			grid.placeWalls();
			checkGameState();
		}
	}, 250);
}
game.update = function () {
	// Game update logic handled by event system and timers
};

===================================================================
--- original.js
+++ change.js
@@ -339,9 +339,9 @@
 						var bomb = new Bomb();
 						bomb.setGridPosition(x, y);
 						self.candies[y][x] = bomb;
 						self.addChild(bomb);
-					} else if (Math.random() < 0.01) {
+					} else if (Math.random() < 0.001) {
 						var superBomb = new SuperBomb();
 						superBomb.setGridPosition(x, y);
 						self.candies[y][x] = superBomb;
 						self.addChild(superBomb);
@@ -552,9 +552,9 @@
 						self.candies[y][x] = bomb;
 						self.addChild(bomb);
 						var targetY = GRID_START_Y + y * CELL_SIZE + CELL_SIZE / 2;
 						bomb.animateToPosition(bomb.x, targetY, 400);
-					} else if (Math.random() < 0.01) {
+					} else if (Math.random() < 0.001) {
 						var superBomb = new SuperBomb();
 						superBomb.x = GRID_START_X + x * CELL_SIZE + CELL_SIZE / 2;
 						superBomb.y = GRID_START_Y - CELL_SIZE;
 						superBomb.gridX = x;