/**** 
* 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 if (currentTheme === 'fruits') {
		candyAssets = ['fruit_apple', 'fruit_banana', 'fruit_cherry', 'fruit_grape', 'fruit_orange', 'fruit_strawberry'];
	} 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 Chest = Container.expand(function () {
	var self = Container.call(this);
	var chestGraphics = self.attachAsset('chest', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Add gentle floating animation
	self.startFloatAnimation = function () {
		var floatAmount = 10; // Float up and down
		var floatDuration = 2000; // 2 seconds
		function floatUp() {
			tween(self, {
				y: self.y - floatAmount
			}, {
				duration: floatDuration,
				easing: tween.easeInOut,
				onFinish: floatDown
			});
		}
		function floatDown() {
			tween(self, {
				y: self.y + floatAmount
			}, {
				duration: floatDuration,
				easing: tween.easeInOut,
				onFinish: floatUp
			});
		}
		floatUp();
	};
	self.startFloatAnimation();
	self.down = function (x, y, obj) {
		// Check if player has earned at least 2000 points total
		var totalScore = storage.totalScore || 0;
		if (totalScore >= 2000) {
			self.openChest();
		} else {
			// Show message that chest is locked
			var lockMessage = new Text2('Sandığı açmak için en az 2000 puan toplamalısın!', {
				size: 50,
				fill: 0xFF0000
			});
			lockMessage.anchor.set(0.5, 0.5);
			lockMessage.x = 1024;
			lockMessage.y = 1800;
			game.addChild(lockMessage);
			// Remove message after 3 seconds
			LK.setTimeout(function () {
				lockMessage.destroy();
			}, 3000);
		}
	};
	self.openChest = function () {
		// Animate chest opening
		tween(self, {
			scaleX: 1.2,
			scaleY: 1.2
		}, {
			duration: 300,
			easing: tween.easeOut,
			onFinish: function onFinish() {
				// Show card selection
				self.showRandomCard();
			}
		});
	};
	self.showRandomCard = function () {
		var cards = [{
			type: 'moves',
			value: 5,
			asset: 'card_moves_5'
		}, {
			type: 'moves',
			value: 10,
			asset: 'card_moves_10'
		}, {
			type: 'moves',
			value: 20,
			asset: 'card_moves_20'
		}, {
			type: 'theme',
			value: 'dark',
			asset: 'card_theme_fastfood'
		}, {
			type: 'theme',
			value: 'fruits',
			asset: 'card_theme_fruits'
		}];
		var randomCard = cards[Math.floor(Math.random() * cards.length)];
		// Create card display
		var cardDisplay = new Container();
		var cardGraphics = cardDisplay.attachAsset(randomCard.asset, {
			anchorX: 0.5,
			anchorY: 0.5
		});
		cardDisplay.x = 1024;
		cardDisplay.y = 1400;
		game.addChild(cardDisplay);
		// Animate card appearing
		cardDisplay.scaleX = 0;
		cardDisplay.scaleY = 0;
		tween(cardDisplay, {
			scaleX: 1,
			scaleY: 1
		}, {
			duration: 500,
			easing: tween.easeOut
		});
		// Apply card effect
		if (randomCard.type === 'moves') {
			var currentMoves = storage.bonusMoves || 0;
			storage.bonusMoves = currentMoves + 1;
			var moveText = new Text2('+1 Hamle Kartı!', {
				size: 60,
				fill: 0x00FF00
			});
			moveText.anchor.set(0.5, 0.5);
			moveText.x = 1024;
			moveText.y = 1700;
			game.addChild(moveText);
		} else if (randomCard.type === 'theme') {
			var unlockedThemes = storage.unlockedThemes || ['classic'];
			if (unlockedThemes.indexOf(randomCard.value) === -1) {
				unlockedThemes.push(randomCard.value);
				storage.unlockedThemes = unlockedThemes;
				var themeText = new Text2('Yeni Tema Açıldı!', {
					size: 60,
					fill: 0xFFD700
				});
				themeText.anchor.set(0.5, 0.5);
				themeText.x = 1024;
				themeText.y = 1700;
				game.addChild(themeText);
			} else {
				// Already unlocked, give bonus moves instead
				var currentMoves = storage.bonusMoves || 0;
				storage.bonusMoves = currentMoves + 1;
				var moveText = new Text2('Tema zaten açık! +1 Hamle!', {
					size: 60,
					fill: 0x00FF00
				});
				moveText.anchor.set(0.5, 0.5);
				moveText.x = 1024;
				moveText.y = 1700;
				game.addChild(moveText);
			}
		}
		// Remove card and chest after 4 seconds
		LK.setTimeout(function () {
			cardDisplay.destroy();
			if (game.children.indexOf(moveText) !== -1) moveText.destroy();
			if (game.children.indexOf(themeText) !== -1) themeText.destroy();
			self.destroy();
		}, 4000);
	};
	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 if (currentTheme === 'fruits') {
								candyType = Math.floor(Math.random() * 6);
							} 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.checkFirecrackerBombCombo = function (centerX, centerY) {
		// Check adjacent positions for bomb-firecracker combination
		var adjacentPositions = [{
			x: centerX - 1,
			y: centerY
		},
		// Left
		{
			x: centerX + 1,
			y: centerY
		},
		// Right
		{
			x: centerX,
			y: centerY - 1
		},
		// Up
		{
			x: centerX,
			y: centerY + 1
		} // Down
		];
		var currentCandy = self.candies[centerY][centerX];
		var hasFirecracker = currentCandy && currentCandy.constructor === Firecracker;
		var hasBomb = currentCandy && currentCandy.constructor === Bomb;
		for (var i = 0; i < adjacentPositions.length; i++) {
			var pos = adjacentPositions[i];
			if (pos.x >= 0 && pos.x < GRID_SIZE && pos.y >= 0 && pos.y < GRID_SIZE) {
				var adjacentCandy = self.candies[pos.y][pos.x];
				if (adjacentCandy) {
					// Check if we have firecracker next to bomb or bomb next to firecracker
					if (hasFirecracker && adjacentCandy.constructor === Bomb || hasBomb && adjacentCandy.constructor === Firecracker) {
						return {
							x: pos.x,
							y: pos.y,
							candy: adjacentCandy
						};
					}
				}
			}
		}
		return null;
	};
	self.explodeAllWalls = function (centerX, centerY, comboX, comboY) {
		var score = 0;
		// Create spectacular animation before exploding walls
		var centerCandy = self.candies[centerY][centerX];
		var comboCandy = self.candies[comboY][comboX];
		// Phase 1: Scale up both candies dramatically
		if (centerCandy) {
			tween(centerCandy, {
				scaleX: 3,
				scaleY: 3,
				rotation: Math.PI * 4
			}, {
				duration: 800,
				easing: tween.easeOut
			});
		}
		if (comboCandy) {
			tween(comboCandy, {
				scaleX: 3,
				scaleY: 3,
				rotation: -Math.PI * 4
			}, {
				duration: 800,
				easing: tween.easeOut
			});
		}
		// Phase 2: Flash screen effect
		LK.setTimeout(function () {
			LK.effects.flashScreen(0xFFFF00, 200); // Yellow flash
			LK.setTimeout(function () {
				LK.effects.flashScreen(0xFF4500, 150); // Orange flash
				LK.setTimeout(function () {
					LK.effects.flashScreen(0xFF0000, 100); // Red flash
				}, 200);
			}, 150);
		}, 400);
		// Phase 3: Create expanding shockwave effect with all walls
		LK.setTimeout(function () {
			LK.getSound('super_bomb_explode').play();
			// Animate all walls before destroying them
			var wallsToDestroy = [];
			for (var x = 0; x < GRID_SIZE; x++) {
				for (var y = 0; y < GRID_SIZE; y++) {
					if (self.walls[y][x]) {
						wallsToDestroy.push({
							wall: self.walls[y][x],
							x: x,
							y: y
						});
					}
				}
			}
			// Animate each wall with staggered timing based on distance from center
			for (var i = 0; i < wallsToDestroy.length; i++) {
				(function (wallData, index) {
					var distance = Math.sqrt(Math.pow(wallData.x - centerX, 2) + Math.pow(wallData.y - centerY, 2));
					var delay = distance * 50; // Stagger based on distance
					LK.setTimeout(function () {
						// Scale up and rotate wall before destroying
						tween(wallData.wall, {
							scaleX: 2.5,
							scaleY: 2.5,
							rotation: Math.PI * 2,
							alpha: 0
						}, {
							duration: 300,
							easing: tween.easeOut,
							onFinish: function onFinish() {
								wallData.wall.destroy();
								self.walls[wallData.y][wallData.x] = null;
								// Spawn a new candy in place of the destroyed wall
								var candyType;
								if (currentTheme === 'classic') {
									candyType = Math.floor(Math.random() * 5);
								} else if (currentTheme === 'fruits') {
									candyType = Math.floor(Math.random() * 6);
								} else {
									candyType = Math.floor(Math.random() * 6);
								}
								var newCandy = new Candy(candyType);
								newCandy.setGridPosition(wallData.x, wallData.y);
								self.candies[wallData.y][wallData.x] = newCandy;
								self.addChild(newCandy);
								// Start with small scale and animate to normal size
								newCandy.scaleX = 0.1;
								newCandy.scaleY = 0.1;
								tween(newCandy, {
									scaleX: 1,
									scaleY: 1
								}, {
									duration: 400,
									easing: tween.easeOut
								});
							}
						});
					}, delay);
				})(wallsToDestroy[i], i);
				score += 50; // Give more points for destroying all walls
			}
		}, 800);
		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 if (currentTheme === 'fruits') {
							candyType = Math.floor(Math.random() * 6);
						} 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);
	// Add treasure chest
	var chest = new Chest();
	chest.x = 1024;
	chest.y = 1600;
	self.addChild(chest);
	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 unlockedThemes = storage.unlockedThemes || ['classic'];
	var classicButton = new MenuButton('KLASİK', function () {
		setTheme('classic');
		startGame();
	});
	classicButton.x = 1024;
	classicButton.y = 700;
	self.addChild(classicButton);
	var darkButton = new MenuButton(unlockedThemes.indexOf('dark') !== -1 ? 'Fast Food' : 'Fast Food (KİTLİ)', function () {
		if (unlockedThemes.indexOf('dark') !== -1) {
			setTheme('dark');
			startGame();
		} else {
			var lockMessage = new Text2('Bu tema kilitli! Sandıktan açabilirsin.', {
				size: 50,
				fill: 0xFF0000
			});
			lockMessage.anchor.set(0.5, 0.5);
			lockMessage.x = 1024;
			lockMessage.y = 1800;
			game.addChild(lockMessage);
			LK.setTimeout(function () {
				lockMessage.destroy();
			}, 3000);
		}
	});
	darkButton.x = 1024;
	darkButton.y = 1100;
	self.addChild(darkButton);
	var fruitButton = new MenuButton(unlockedThemes.indexOf('fruits') !== -1 ? 'Meyveler' : 'Meyveler (KİTLİ)', function () {
		if (unlockedThemes.indexOf('fruits') !== -1) {
			setTheme('fruits');
			startGame();
		} else {
			var lockMessage = new Text2('Bu tema kilitli! Sandıktan açabilirsin.', {
				size: 50,
				fill: 0xFF0000
			});
			lockMessage.anchor.set(0.5, 0.5);
			lockMessage.x = 1024;
			lockMessage.y = 1800;
			game.addChild(lockMessage);
			LK.setTimeout(function () {
				lockMessage.destroy();
			}, 3000);
		}
	});
	fruitButton.x = 1024;
	fruitButton.y = 1500;
	self.addChild(fruitButton);
	return self;
	var resetButton = new MenuButton('TEMA SIFIRLA', function () {
		// Reset unlocked themes to only classic
		storage.unlockedThemes = ['classic'];
		// Reset current theme to classic
		storage.theme = 'classic';
		currentTheme = 'classic';
		// Show confirmation message
		var resetMessage = new Text2('Temalar sıfırlandı! Sadece klasik tema açık.', {
			size: 50,
			fill: 0x00FF00
		});
		resetMessage.anchor.set(0.5, 0.5);
		resetMessage.x = 1024;
		resetMessage.y = 1800;
		game.addChild(resetMessage);
		LK.setTimeout(function () {
			resetMessage.destroy();
			// Refresh theme selection to show updated state
			showThemeSelection();
		}, 2000);
	});
	resetButton.x = 1024;
	resetButton.y = 1900;
	resetButton.scaleX = 0.8;
	resetButton.scaleY = 0.8;
	self.addChild(resetButton);
	var resetMoveCardsButton = new MenuButton('HAMLE KARTLARINI SIFIRLA', function () {
		resetMoveCards();
	});
	resetMoveCardsButton.x = 1024;
	resetMoveCardsButton.y = 2100;
	resetMoveCardsButton.scaleX = 0.7;
	resetMoveCardsButton.scaleY = 0.7;
	self.addChild(resetMoveCardsButton);
	var resetGameButton = new MenuButton('OYUNU SIFIRLA', function () {
		resetGame();
	});
	resetGameButton.x = 1024;
	resetGameButton.y = 2300;
	resetGameButton.scaleX = 0.7;
	resetGameButton.scaleY = 0.7;
	self.addChild(resetGameButton);
});
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 currentScore = 0;
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;
var movesLeft = 30;
var maxMoves = 30;
var bonusMoves = storage.bonusMoves || 0;
var usedMoveCards = storage.usedMoveCards || false;
// 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 processDepth = 0;
	var maxDepth = 10;
	function processMatchesInner() {
		if (processDepth >= maxDepth) {
			isProcessing = false;
			checkGameState();
			return;
		}
		var matches = grid.findMatches();
		if (matches.length > 0) {
			processDepth++;
			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;
						}
						processMatchesInner(); // Check for chain reactions with depth control
					}, 500);
				}, 300);
			}, 300);
		} else {
			isProcessing = false;
			checkGameState();
		}
	}
	processMatchesInner();
}
function hasValidMoves() {
	if (!grid || !grid.candies) return false;
	// Check all possible adjacent swaps
	for (var y = 0; y < GRID_SIZE; y++) {
		for (var x = 0; x < GRID_SIZE; x++) {
			if (!grid.candies[y] || !grid.candies[y][x] || grid.walls[y] && grid.walls[y][x]) continue;
			// Check right neighbor
			if (x + 1 < GRID_SIZE && grid.candies[y][x + 1] && (!grid.walls[y] || !grid.walls[y][x + 1])) {
				// Temporarily swap
				var candy1 = grid.candies[y][x];
				var candy2 = grid.candies[y][x + 1];
				if (candy1 && candy2 && candy1.candyType !== undefined && candy2.candyType !== undefined) {
					grid.candies[y][x] = candy2;
					grid.candies[y][x + 1] = candy1;
					// Check if this creates matches
					var matches = grid.findMatches();
					// Swap back
					grid.candies[y][x] = candy1;
					grid.candies[y][x + 1] = candy2;
					if (matches.length > 0) return true;
				}
			}
			// Check bottom neighbor
			if (y + 1 < GRID_SIZE && grid.candies[y + 1] && grid.candies[y + 1][x] && (!grid.walls[y + 1] || !grid.walls[y + 1][x])) {
				// Temporarily swap
				var candy1 = grid.candies[y][x];
				var candy2 = grid.candies[y + 1][x];
				if (candy1 && candy2 && candy1.candyType !== undefined && candy2.candyType !== undefined) {
					grid.candies[y][x] = candy2;
					grid.candies[y + 1][x] = candy1;
					// Check if this creates matches
					var matches = grid.findMatches();
					// Swap back
					grid.candies[y][x] = candy1;
					grid.candies[y + 1][x] = candy2;
					if (matches.length > 0) return true;
				}
			}
		}
	}
	return false;
}
function checkGameState() {
	if (gameState !== 'playing' || isProcessing) return;
	// Check if moves are exhausted or no valid moves remain
	if (movesLeft <= 0 || !hasValidMoves()) {
		gameState = 'gameover';
		// Track total score across all games
		var totalScore = storage.totalScore || 0;
		storage.totalScore = totalScore + currentScore;
		// Check if current score is a new high score
		if (currentScore > highScore) {
			highScore = currentScore;
			storage.highScore = highScore;
		}
		LK.showGameOver();
	}
}
function setTheme(theme) {
	currentTheme = theme;
	storage.theme = theme;
	updateThemeColors();
}
function updateThemeColors() {
	if (currentTheme === 'dark') {
		game.setBackgroundColor(0x111111);
	} else if (currentTheme === 'fruits') {
		game.setBackgroundColor(0x228B22); // Forest green background for fruit theme
	} 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;
	// Don't automatically use bonus moves at start, let player choose when to use them
	movesLeft = maxMoves;
	bonusMoves = storage.bonusMoves || 0;
	// Reset move card usage for new game
	usedMoveCards = false;
	storage.usedMoveCards = false;
	selectedCandy = null;
	isProcessing = false;
	if (mainMenu) {
		mainMenu.destroy();
		mainMenu = null;
	}
	if (themeSelection) {
		themeSelection.destroy();
		themeSelection = null;
	}
	updateThemeColors();
	// Play the second music track when game starts
	LK.playMusic('Candy');
	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);
	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);
	movesText = new Text2('Moves: ' + movesLeft, {
		size: 50,
		fill: 0x00FF00
	});
	movesText.anchor.set(0.5, 0);
	movesText.y = 200;
	LK.gui.top.addChild(movesText);
	// Add move cards display and use button
	var moveCardsCount = storage.bonusMoves || 0;
	var moveCardsText = new Text2('Hamle Kartları: ' + moveCardsCount, {
		size: 45,
		fill: 0x00FFFF
	});
	moveCardsText.anchor.set(0.5, 0);
	moveCardsText.y = 250;
	LK.gui.top.addChild(moveCardsText);
	// Add use move card button
	var useMoveCardButton = new MenuButton(usedMoveCards ? 'KULLANILDI (KİTLİ)' : 'HAMLE KARTI KULLAN', function () {
		if (usedMoveCards) {
			// Show message that already used
			var usedMessage = new Text2('Bu oyunda zaten hamle kartı kullandın!', {
				size: 50,
				fill: 0xFF0000
			});
			usedMessage.anchor.set(0.5, 0.5);
			usedMessage.x = 1024;
			usedMessage.y = 1000;
			game.addChild(usedMessage);
			LK.setTimeout(function () {
				usedMessage.destroy();
			}, 3000);
			return;
		}
		var currentMoveCards = storage.bonusMoves || 0;
		if (currentMoveCards > 0) {
			showMoveCardSelection();
		} else {
			// Show message that no cards available
			var noCardsMessage = new Text2('Hamle kartın yok! Sandıktan edinebilirsin.', {
				size: 50,
				fill: 0xFF0000
			});
			noCardsMessage.anchor.set(0.5, 0.5);
			noCardsMessage.x = 1024;
			noCardsMessage.y = 1000;
			game.addChild(noCardsMessage);
			LK.setTimeout(function () {
				noCardsMessage.destroy();
			}, 3000);
		}
	});
	useMoveCardButton.scaleX = 0.2;
	useMoveCardButton.scaleY = 0.2;
	useMoveCardButton.x = 1900;
	useMoveCardButton.y = 50;
	gameUI.addChild(useMoveCardButton);
}
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) {
			// Check if there's an adjacent firecracker for combination
			var comboCandy = grid.checkFirecrackerBombCombo(candyInfo.x, candyInfo.y);
			if (comboCandy) {
				// Start spectacular combo animation, then explode all walls
				var points = grid.explodeAllWalls(candyInfo.x, candyInfo.y, comboCandy.x, comboCandy.y);
				currentScore += points;
				if (scoreText) scoreText.setText('Score: ' + currentScore);
				// Delay the candy destruction to allow animation to complete
				LK.setTimeout(function () {
					candyInfo.candy.explode();
					comboCandy.candy.explode();
					grid.candies[candyInfo.y][candyInfo.x] = null;
					grid.candies[comboCandy.y][comboCandy.x] = null;
				}, 1200);
			} else {
				// Regular bomb explosion - 3x3 area
				var points = grid.explodeBomb(candyInfo.x, candyInfo.y);
				currentScore += points;
				if (scoreText) scoreText.setText('Score: ' + currentScore);
			}
			// Decrease moves counter
			movesLeft--;
			if (movesText) 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);
			// Decrease moves counter
			movesLeft--;
			if (movesText) 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) {
			// Check if there's an adjacent bomb for combination
			var comboCandy = grid.checkFirecrackerBombCombo(candyInfo.x, candyInfo.y);
			if (comboCandy) {
				// Start spectacular combo animation, then explode all walls
				var points = grid.explodeAllWalls(candyInfo.x, candyInfo.y, comboCandy.x, comboCandy.y);
				currentScore += points;
				if (scoreText) scoreText.setText('Score: ' + currentScore);
				// Delay the candy destruction to allow animation to complete
				LK.setTimeout(function () {
					candyInfo.candy.explode();
					comboCandy.candy.explode();
					grid.candies[candyInfo.y][candyInfo.x] = null;
					grid.candies[comboCandy.y][comboCandy.x] = null;
				}, 1200);
			} else {
				// Regular firecracker explosion - entire row
				var firecrackerRow = candyInfo.y;
				var points = grid.explodeRow(firecrackerRow);
				currentScore += points;
				if (scoreText) scoreText.setText('Score: ' + currentScore);
			}
			// Decrease moves counter
			movesLeft--;
			if (movesText) 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 showMoveCardSelection() {
	// Create selection popup container
	var selectionPopup = new Container();
	game.addChild(selectionPopup);
	// Create semi-transparent background
	var background = LK.getAsset('gridCell', {
		anchorX: 0.5,
		anchorY: 0.5,
		x: 1024,
		y: 1366,
		scaleX: 12,
		scaleY: 16,
		alpha: 0.8
	});
	background.tint = 0x000000;
	selectionPopup.addChild(background);
	// Title text
	var titleText = new Text2('Hangi hamle kartını kullanmak istiyorsunuz?', {
		size: 60,
		fill: 0xFFFFFF
	});
	titleText.anchor.set(0.5, 0.5);
	titleText.x = 1024;
	titleText.y = 900;
	selectionPopup.addChild(titleText);
	// +5 moves card button
	var card5Button = new MenuButton('+5 HAMLE', function () {
		useMoveCard(5);
		selectionPopup.destroy();
	});
	card5Button.x = 1024;
	card5Button.y = 1200;
	card5Button.scaleX = 0.8;
	card5Button.scaleY = 0.8;
	selectionPopup.addChild(card5Button);
	// +10 moves card button  
	var card10Button = new MenuButton('+10 HAMLE', function () {
		useMoveCard(10);
		selectionPopup.destroy();
	});
	card10Button.x = 1024;
	card10Button.y = 1400;
	card10Button.scaleX = 0.8;
	card10Button.scaleY = 0.8;
	selectionPopup.addChild(card10Button);
	// +20 moves card button
	var card20Button = new MenuButton('+20 HAMLE', function () {
		useMoveCard(20);
		selectionPopup.destroy();
	});
	card20Button.x = 1024;
	card20Button.y = 1600;
	card20Button.scaleX = 0.8;
	card20Button.scaleY = 0.8;
	selectionPopup.addChild(card20Button);
	// Close button
	var closeButton = new MenuButton('KAPAT', function () {
		selectionPopup.destroy();
	});
	closeButton.x = 1024;
	closeButton.y = 1800;
	closeButton.scaleX = 0.6;
	closeButton.scaleY = 0.6;
	selectionPopup.addChild(closeButton);
}
function resetMoveCards() {
	// Reset move cards to 0
	storage.bonusMoves = 0;
	// Show confirmation message
	var resetMessage = new Text2('Hamle kartları sıfırlandı!', {
		size: 50,
		fill: 0x00FF00
	});
	resetMessage.anchor.set(0.5, 0.5);
	resetMessage.x = 1024;
	resetMessage.y = 1000;
	game.addChild(resetMessage);
	LK.setTimeout(function () {
		resetMessage.destroy();
	}, 2000);
}
function resetGame() {
	// Reset move cards to 0
	storage.bonusMoves = 0;
	// Reset unlocked themes to only classic
	storage.unlockedThemes = ['classic'];
	// Reset current theme to classic
	storage.theme = 'classic';
	currentTheme = 'classic';
	// Reset high score
	storage.highScore = 0;
	highScore = 0;
	// Reset total score
	storage.totalScore = 0;
	// Reset used move cards flag
	storage.usedMoveCards = false;
	usedMoveCards = false;
	// Show confirmation message
	var resetMessage = new Text2('Oyun tamamen sıfırlandı! Tüm kartlar ve temalar kilitlendi.', {
		size: 50,
		fill: 0xFF0000
	});
	resetMessage.anchor.set(0.5, 0.5);
	resetMessage.x = 1024;
	resetMessage.y = 1000;
	game.addChild(resetMessage);
	LK.setTimeout(function () {
		resetMessage.destroy();
		// Refresh main menu to show updated state
		showMainMenu();
	}, 3000);
}
function useMoveCard(moveAmount) {
	var currentMoveCards = storage.bonusMoves || 0;
	if (currentMoveCards > 0 && !usedMoveCards) {
		// Use one move card to get extra moves
		storage.bonusMoves = currentMoveCards - 1;
		movesLeft += moveAmount;
		maxMoves += moveAmount;
		// Mark move cards as used for this game session
		usedMoveCards = true;
		storage.usedMoveCards = true;
		// Update UI
		movesText.setText('Moves: ' + movesLeft);
		var moveCardsText = LK.gui.top.children.find(function (child) {
			return child.text && child.text.indexOf('Hamle Kartları:') !== -1;
		});
		if (moveCardsText) {
			moveCardsText.setText('Hamle Kartları: ' + storage.bonusMoves);
		}
		// Show confirmation message
		var useMessage = new Text2('+' + moveAmount + ' Hamle Eklendi! (Bu oyunda bir daha kullanamaz)', {
			size: 45,
			fill: 0x00FF00
		});
		useMessage.anchor.set(0.5, 0.5);
		useMessage.x = 1024;
		useMessage.y = 1000;
		game.addChild(useMessage);
		LK.setTimeout(function () {
			useMessage.destroy();
		}, 3000);
	}
}
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) {
			// Decrease moves counter
			movesLeft--;
			if (movesText) movesText.setText('Moves: ' + movesLeft);
			// Add one wall after each move
			grid.placeWalls();
			processMatches();
		} else {
			// Swap back if no matches
			grid.swapCandies(candyInfo2.x, candyInfo2.y, candyInfo1.x, candyInfo1.y);
			// Decrease moves counter even for failed moves
			movesLeft--;
			if (movesText) 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
@@ -1183,8 +1183,16 @@
 	resetMoveCardsButton.y = 2100;
 	resetMoveCardsButton.scaleX = 0.7;
 	resetMoveCardsButton.scaleY = 0.7;
 	self.addChild(resetMoveCardsButton);
+	var resetGameButton = new MenuButton('OYUNU SIFIRLA', function () {
+		resetGame();
+	});
+	resetGameButton.x = 1024;
+	resetGameButton.y = 2300;
+	resetGameButton.scaleX = 0.7;
+	resetGameButton.scaleY = 0.7;
+	self.addChild(resetGameButton);
 });
 var Wall = Container.expand(function () {
 	var self = Container.call(this);
 	self.gridX = 0;
@@ -1736,8 +1744,39 @@
 	LK.setTimeout(function () {
 		resetMessage.destroy();
 	}, 2000);
 }
+function resetGame() {
+	// Reset move cards to 0
+	storage.bonusMoves = 0;
+	// Reset unlocked themes to only classic
+	storage.unlockedThemes = ['classic'];
+	// Reset current theme to classic
+	storage.theme = 'classic';
+	currentTheme = 'classic';
+	// Reset high score
+	storage.highScore = 0;
+	highScore = 0;
+	// Reset total score
+	storage.totalScore = 0;
+	// Reset used move cards flag
+	storage.usedMoveCards = false;
+	usedMoveCards = false;
+	// Show confirmation message
+	var resetMessage = new Text2('Oyun tamamen sıfırlandı! Tüm kartlar ve temalar kilitlendi.', {
+		size: 50,
+		fill: 0xFF0000
+	});
+	resetMessage.anchor.set(0.5, 0.5);
+	resetMessage.x = 1024;
+	resetMessage.y = 1000;
+	game.addChild(resetMessage);
+	LK.setTimeout(function () {
+		resetMessage.destroy();
+		// Refresh main menu to show updated state
+		showMainMenu();
+	}, 3000);
+}
 function useMoveCard(moveAmount) {
 	var currentMoveCards = storage.bonusMoves || 0;
 	if (currentMoveCards > 0 && !usedMoveCards) {
 		// Use one move card to get extra moves