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

/**** 
* Classes
****/ 
var Ball = Container.expand(function (color) {
	var self = Container.call(this);
	self.ballColor = color;
	self.gridX = 0;
	self.gridY = 0;
	self.isAnimating = false;
	var ballAssets = ['redBall', 'blueBall', 'greenBall', 'yellowBall', 'purpleBall', 'orangeBall'];
	var assetToUse = ballAssets[color];
	var ballGraphics = self.attachAsset(assetToUse, {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.setGridPosition = function (gridX, gridY) {
		self.gridX = gridX;
		self.gridY = gridY;
		self.x = gridStartX + gridX * cellSize + cellSize / 2;
		self.y = gridStartY + gridY * cellSize + cellSize / 2;
	};
	self.explode = function () {
		// Scale up and fade out explosion effect
		tween(self, {
			scaleX: 1.3,
			scaleY: 1.3,
			alpha: 0
		}, {
			duration: 600,
			easing: tween.easeInOut,
			onFinish: function onFinish() {
				if (self.parent) {
					self.destroy();
				}
			}
		});
	};
	return self;
});
var Bomb = Container.expand(function () {
	var self = Container.call(this);
	self.gridX = 0;
	self.gridY = 0;
	self.isAnimating = false;
	self.isBomb = true;
	self.isDragging = false;
	// Create bomb visual using the Bomba asset
	var bombGraphics = self.attachAsset('Bomba', {
		anchorX: 0.5,
		anchorY: 0.5,
		scaleX: 0.8,
		scaleY: 0.8
	});
	// Add pulsing animation to make it stand out
	self.pulseAnimation = function () {
		tween(self, {
			scaleX: 1.1,
			scaleY: 1.1
		}, {
			duration: 500,
			easing: tween.easeInOut,
			onFinish: function onFinish() {
				tween(self, {
					scaleX: 0.8,
					scaleY: 0.8
				}, {
					duration: 500,
					easing: tween.easeInOut,
					onFinish: function onFinish() {
						if (self.parent && !self.isDragging) {
							self.pulseAnimation();
						}
					}
				});
			}
		});
	};
	self.setGridPosition = function (gridX, gridY) {
		self.gridX = gridX;
		self.gridY = gridY;
		self.x = gridStartX + gridX * cellSize + cellSize / 2;
		self.y = gridStartY + gridY * cellSize + cellSize / 2;
	};
	self.explode = function () {
		// Simple bomb explosion effect (same as Ball explode method)
		tween(self, {
			scaleX: 1.3,
			scaleY: 1.3,
			alpha: 0
		}, {
			duration: 600,
			easing: tween.easeInOut,
			onFinish: function onFinish() {
				if (self.parent) {
					self.destroy();
				}
			}
		});
	};
	self.explode3x3 = function () {
		// Explode all balls in a 3x3 area around the bomb
		var centerX = self.gridX;
		var centerY = self.gridY;
		var explodedCount = 0;
		for (var dx = -1; dx <= 1; dx++) {
			for (var dy = -1; dy <= 1; dy++) {
				var targetX = centerX + dx;
				var targetY = centerY + dy;
				if (targetX >= 0 && targetX < gridSize && targetY >= 0 && targetY < gridSize) {
					var ball = grid[targetY][targetX];
					if (ball) {
						// If it's a chained ball, break the chain first
						if (ball.isChained) {
							ball.breakChain();
							// Give extra points for breaking chains with bombs
							LK.setScore(LK.getScore() + 5);
						}
						ball.explode();
						grid[targetY][targetX] = null;
						explodedCount++;
					}
				}
			}
		}
		// Award points for exploded balls
		LK.setScore(LK.getScore() + explodedCount * 15);
		scoreText.setText('Score: ' + LK.getScore());
		// Update progress bar
		var currentScore = LK.getScore();
		var progress = Math.min(1, currentScore % 400 / 400);
		progressBarFill.width = progress * 400;
		progressText.setText(currentScore % 400 + '/400');
		checkLevelProgression();
		// Remove bomb from grid
		grid[self.gridY][self.gridX] = null;
		// Explosion effect for bomb itself
		tween(self, {
			scaleX: 2,
			scaleY: 2,
			alpha: 0
		}, {
			duration: 400,
			easing: tween.easeOut,
			onFinish: function onFinish() {
				if (self.parent) {
					self.destroy();
				}
			}
		});
	};
	// Start pulsing animation when created
	self.pulseAnimation();
	return self;
});
var ChainedBall = Container.expand(function (color) {
	var self = Container.call(this);
	self.ballColor = color;
	self.gridX = 0;
	self.gridY = 0;
	self.isAnimating = false;
	self.isChained = true;
	// Create chain background first (larger, darker)
	var chainGraphics = self.attachAsset('chain', {
		anchorX: 0.5,
		anchorY: 0.5,
		alpha: 0.7
	});
	// Create ball on top of chain
	var ballAssets = ['redBall', 'blueBall', 'greenBall', 'yellowBall', 'purpleBall', 'orangeBall'];
	var assetToUse = ballAssets[color];
	var ballGraphics = self.attachAsset(assetToUse, {
		anchorX: 0.5,
		anchorY: 0.5,
		scaleX: 0.85,
		scaleY: 0.85
	});
	// Add subtle chain animation
	self.chainAnimation = function () {
		tween(chainGraphics, {
			rotation: 0.1
		}, {
			duration: 1000,
			easing: tween.easeInOut,
			onFinish: function onFinish() {
				tween(chainGraphics, {
					rotation: -0.1
				}, {
					duration: 1000,
					easing: tween.easeInOut,
					onFinish: function onFinish() {
						if (self.parent && self.isChained) {
							self.chainAnimation();
						}
					}
				});
			}
		});
	};
	self.setGridPosition = function (gridX, gridY) {
		self.gridX = gridX;
		self.gridY = gridY;
		self.x = gridStartX + gridX * cellSize + cellSize / 2;
		self.y = gridStartY + gridY * cellSize + cellSize / 2;
	};
	self.explode = function () {
		// Scale up and fade out explosion effect
		tween(self, {
			scaleX: 1.3,
			scaleY: 1.3,
			alpha: 0
		}, {
			duration: 600,
			easing: tween.easeInOut,
			onFinish: function onFinish() {
				if (self.parent) {
					self.destroy();
				}
			}
		});
	};
	self.breakChain = function () {
		// Break the chain and convert to regular ball
		self.isChained = false;
		// Animate chain breaking
		tween(chainGraphics, {
			scaleX: 1.5,
			scaleY: 1.5,
			alpha: 0
		}, {
			duration: 300,
			easing: tween.easeOut
		});
		// Scale ball back to normal size
		tween(ballGraphics, {
			scaleX: 1.0,
			scaleY: 1.0
		}, {
			duration: 300,
			easing: tween.easeOut
		});
		// Flash effect when chain breaks
		LK.effects.flashObject(self, 0xFFFFFF, 400);
	};
	// Start chain animation
	self.chainAnimation();
	return self;
});
var HealthBox = Container.expand(function () {
	var self = Container.call(this);
	self.gridX = 0;
	self.gridY = 0;
	self.isAnimating = false;
	self.isHealthBox = true;
	self.isDragging = false;
	// Create health box visual using the healthBox asset
	var healthGraphics = self.attachAsset('healthBox', {
		anchorX: 0.5,
		anchorY: 0.5,
		scaleX: 0.8,
		scaleY: 0.8
	});
	// Add gentle glow animation
	self.glowAnimation = function () {
		tween(self, {
			alpha: 0.7
		}, {
			duration: 800,
			easing: tween.easeInOut,
			onFinish: function onFinish() {
				tween(self, {
					alpha: 1.0
				}, {
					duration: 800,
					easing: tween.easeInOut,
					onFinish: function onFinish() {
						if (self.parent && !self.isDragging) {
							self.glowAnimation();
						}
					}
				});
			}
		});
	};
	self.setGridPosition = function (gridX, gridY) {
		self.gridX = gridX;
		self.gridY = gridY;
		self.x = gridStartX + gridX * cellSize + cellSize / 2;
		self.y = gridStartY + gridY * cellSize + cellSize / 2;
	};
	self.explode = function () {
		// Simple health box explosion effect
		tween(self, {
			scaleX: 1.3,
			scaleY: 1.3,
			alpha: 0
		}, {
			duration: 600,
			easing: tween.easeInOut,
			onFinish: function onFinish() {
				if (self.parent) {
					self.destroy();
				}
			}
		});
	};
	self.activateHealthBonus = function () {
		// Add 8 moves when health box is clicked
		movesLeft += 8;
		movesText.setText('Moves: ' + movesLeft);
		// Remove health box from grid
		grid[self.gridY][self.gridX] = null;
		// Visual effect for health box activation
		tween(self, {
			scaleX: 1.5,
			scaleY: 1.5,
			alpha: 0
		}, {
			duration: 400,
			easing: tween.easeOut,
			onFinish: function onFinish() {
				if (self.parent) {
					self.destroy();
				}
			}
		});
		// Flash screen green to indicate health bonus
		LK.effects.flashScreen(0x00FF00, 500);
	};
	// Start glow animation when created
	self.glowAnimation();
	return self;
});

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

/**** 
* Game Code
****/ 
// Grid configuration variables needed by Ball class
var gridSize = 8;
var cellSize = 220;
var gridStartX = (2048 - gridSize * cellSize) / 2;
var gridStartY = 400;
var grid = [];
var gridShape = []; // Array to define which cells are active in current level
// Define different grid shapes for each level
var levelShapes = [
// Level 1: Full 8x8 square
function (size) {
	var shape = [];
	for (var y = 0; y < size; y++) {
		shape[y] = [];
		for (var x = 0; x < size; x++) {
			shape[y][x] = true;
		}
	}
	return shape;
},
// Level 2: Diamond shape
function (size) {
	var shape = [];
	var center = Math.floor(size / 2);
	for (var y = 0; y < size; y++) {
		shape[y] = [];
		for (var x = 0; x < size; x++) {
			var distanceFromCenter = Math.abs(x - center) + Math.abs(y - center);
			shape[y][x] = distanceFromCenter <= center;
		}
	}
	return shape;
},
// Level 3: Cross shape
function (size) {
	var shape = [];
	var center = Math.floor(size / 2);
	for (var y = 0; y < size; y++) {
		shape[y] = [];
		for (var x = 0; x < size; x++) {
			shape[y][x] = x === center || y === center;
		}
	}
	return shape;
},
// Level 4: Hollow square (border only)
function (size) {
	var shape = [];
	for (var y = 0; y < size; y++) {
		shape[y] = [];
		for (var x = 0; x < size; x++) {
			shape[y][x] = x === 0 || x === size - 1 || y === 0 || y === size - 1;
		}
	}
	return shape;
},
// Level 5: X shape
function (size) {
	var shape = [];
	for (var y = 0; y < size; y++) {
		shape[y] = [];
		for (var x = 0; x < size; x++) {
			shape[y][x] = x === y || x === size - 1 - y;
		}
	}
	return shape;
},
// Level 6: Circle shape
function (size) {
	var shape = [];
	var center = size / 2 - 0.5;
	var radius = center;
	for (var y = 0; y < size; y++) {
		shape[y] = [];
		for (var x = 0; x < size; x++) {
			var dx = x - center;
			var dy = y - center;
			var distance = Math.sqrt(dx * dx + dy * dy);
			shape[y][x] = distance <= radius;
		}
	}
	return shape;
}];
// Function to get current level's grid shape
function getCurrentGridShape() {
	var shapeIndex = (currentLevel - 1) % levelShapes.length;
	return levelShapes[shapeIndex](gridSize);
}
// Function to check if a grid position is valid for current shape
function isValidGridPosition(x, y) {
	return gridShape[y] && gridShape[y][x];
}
var selectedBall = null;
var movesLeft = 40;
var isProcessingMatches = false;
var ballColors = 4; // Start with 4 colors for easier beginning
var bombSpawnChance = 0.01; // 1% chance to spawn bomb instead of ball
var healthBoxSpawnChance = 0.04; // 4% chance to spawn health box instead of ball
var draggedBomb = null;
var lastMoveTime = 0;
var currentLevel = 1;
var baseMovesPerLevel = 30;
var pointsToNextLevel = 400; // Points needed to advance to next level
var totalPointsEarned = 0;
// UI Elements
var movesText = new Text2('Moves: 40', {
	size: 80,
	fill: 0xFFFFFF
});
movesText.anchor.set(0.5, 0);
LK.gui.top.addChild(movesText);
movesText.y = 150;
var scoreText = new Text2('Score: 0', {
	size: 80,
	fill: 0xFFFFFF
});
scoreText.anchor.set(0, 0);
LK.gui.top.addChild(scoreText);
scoreText.x = 150;
scoreText.y = 250;
// Progress bar to show points needed for next level
var progressBarBackground = LK.getAsset('gridCell', {
	width: 400,
	height: 40,
	anchorX: 1.0,
	anchorY: 0,
	alpha: 0.3
});
LK.gui.topRight.addChild(progressBarBackground);
progressBarBackground.x = -50;
progressBarBackground.y = 150;
var progressBarFill = LK.getAsset('gridCell', {
	width: 1,
	height: 40,
	anchorX: 0,
	anchorY: 0,
	color: 0x00FF00
});
progressBarBackground.addChild(progressBarFill);
var progressText = new Text2('0/400', {
	size: 50,
	fill: 0xFFFFFF
});
progressText.anchor.set(1, 0);
LK.gui.topRight.addChild(progressText);
progressText.x = -50;
progressText.y = 200;
// Initialize grid
function initializeGrid() {
	// Get the shape for current level
	gridShape = getCurrentGridShape();
	grid = [];
	for (var y = 0; y < gridSize; y++) {
		grid[y] = [];
		for (var x = 0; x < gridSize; x++) {
			grid[y][x] = null;
		}
	}
	// Fill grid with balls only in valid positions
	for (var y = 0; y < gridSize; y++) {
		for (var x = 0; x < gridSize; x++) {
			if (isValidGridPosition(x, y)) {
				createBallAt(x, y);
			}
		}
	}
	// Remove initial matches
	while (findMatches().length > 0) {
		removeMatches();
		dropBalls();
		fillEmptySpaces();
	}
}
function createBallAt(x, y) {
	// Only create balls in valid grid positions
	if (!isValidGridPosition(x, y)) {
		return null;
	}
	// Also check if position is within grid bounds
	if (x < 0 || x >= gridSize || y < 0 || y >= gridSize) {
		return null;
	}
	// Sometimes create a bomb instead of a ball
	if (Math.random() < bombSpawnChance) {
		var bomb = new Bomb();
		bomb.setGridPosition(x, y);
		grid[y][x] = bomb;
		game.addChild(bomb);
		// Animate bomb appearing
		bomb.scaleX = 0;
		bomb.scaleY = 0;
		bomb.alpha = 0;
		tween(bomb, {
			scaleX: 0.8,
			scaleY: 0.8,
			alpha: 1
		}, {
			duration: 400,
			easing: tween.easeOut
		});
		return bomb;
	} else if (Math.random() < healthBoxSpawnChance) {
		var healthBox = new HealthBox();
		healthBox.setGridPosition(x, y);
		grid[y][x] = healthBox;
		game.addChild(healthBox);
		// Animate health box appearing
		healthBox.scaleX = 0;
		healthBox.scaleY = 0;
		healthBox.alpha = 0;
		tween(healthBox, {
			scaleX: 0.8,
			scaleY: 0.8,
			alpha: 1
		}, {
			duration: 400,
			easing: tween.easeOut
		});
		return healthBox;
	} else if (Math.random() < 0.05) {
		// 5% chance to create chained ball
		var color = Math.floor(Math.random() * ballColors);
		var chainedBall = new ChainedBall(color);
		chainedBall.setGridPosition(x, y);
		grid[y][x] = chainedBall;
		game.addChild(chainedBall);
		// Animate chained ball appearing
		chainedBall.scaleX = 0;
		chainedBall.scaleY = 0;
		chainedBall.alpha = 0;
		tween(chainedBall, {
			scaleX: 1,
			scaleY: 1,
			alpha: 1
		}, {
			duration: 400,
			easing: tween.easeOut
		});
		return chainedBall;
	} else {
		var color = Math.floor(Math.random() * ballColors);
		var ball = new Ball(color);
		ball.setGridPosition(x, y);
		grid[y][x] = ball;
		game.addChild(ball);
		// Animate ball appearing with scale and bounce
		ball.scaleX = 0;
		ball.scaleY = 0;
		ball.alpha = 0;
		tween(ball, {
			scaleX: 1,
			scaleY: 1,
			alpha: 1
		}, {
			duration: 400,
			easing: tween.easeOut
		});
		return ball;
	}
}
function getBallAt(x, y) {
	if (x < 0 || x >= gridSize || y < 0 || y >= gridSize) {
		return null;
	}
	return grid[y][x];
}
function swapBalls(ball1, ball2) {
	if (!ball1 || !ball2) {
		return false;
	}
	// Check if either ball is chained - they cannot be moved
	if (ball1.isChained && ball1.isChained === true || ball2.isChained && ball2.isChained === true) {
		// Flash red to indicate chained balls cannot move
		LK.effects.flashScreen(0xFF0000, 200);
		return false;
	}
	var x1 = ball1.gridX,
		y1 = ball1.gridY;
	var x2 = ball2.gridX,
		y2 = ball2.gridY;
	// Check if balls are adjacent
	var dx = Math.abs(x1 - x2);
	var dy = Math.abs(y1 - y2);
	if (dx + dy !== 1) {
		return false;
	}
	// Mark balls as animating
	ball1.isAnimating = true;
	ball2.isAnimating = true;
	// Store old positions
	var oldX1 = ball1.x,
		oldY1 = ball1.y;
	var oldX2 = ball2.x,
		oldY2 = ball2.y;
	// Swap positions in grid
	grid[y1][x1] = ball2;
	grid[y2][x2] = ball1;
	// Update ball positions
	ball1.setGridPosition(x2, y2);
	ball2.setGridPosition(x1, y1);
	// Store new positions
	var newX1 = ball1.x,
		newY1 = ball1.y;
	var newX2 = ball2.x,
		newY2 = ball2.y;
	// Reset to old positions for animation
	ball1.x = oldX1;
	ball1.y = oldY1;
	ball2.x = oldX2;
	ball2.y = oldY2;
	// Animate to new positions
	tween(ball1, {
		x: newX1,
		y: newY1
	}, {
		duration: 250,
		easing: tween.easeInOut,
		onFinish: function onFinish() {
			ball1.isAnimating = false;
		}
	});
	tween(ball2, {
		x: newX2,
		y: newY2
	}, {
		duration: 250,
		easing: tween.easeInOut,
		onFinish: function onFinish() {
			ball2.isAnimating = false;
		}
	});
	LK.getSound('swap').play();
	return true;
}
function findMatches() {
	var matches = [];
	// Check horizontal matches
	for (var y = 0; y < gridSize; y++) {
		var count = 0;
		var currentColor = -1;
		var matchPositions = [];
		for (var x = 0; x < gridSize; x++) {
			if (!isValidGridPosition(x, y)) {
				// Invalid position, reset match counting
				if (count >= 3) {
					for (var i = 0; i < matchPositions.length; i++) {
						matches.push(matchPositions[i]);
					}
				}
				count = 0;
				currentColor = -1;
				matchPositions = [];
				continue;
			}
			var ball = grid[y][x];
			if (ball && ball.ballColor !== undefined && ball.ballColor === currentColor) {
				count++;
				matchPositions.push({
					x: x,
					y: y
				});
			} else {
				if (count >= 3) {
					for (var i = 0; i < matchPositions.length; i++) {
						matches.push(matchPositions[i]);
					}
				}
				count = ball && ball.ballColor !== undefined ? 1 : 0;
				currentColor = ball && ball.ballColor !== undefined ? ball.ballColor : -1;
				matchPositions = ball && ball.ballColor !== undefined ? [{
					x: x,
					y: y
				}] : [];
			}
		}
		if (count >= 3) {
			for (var i = 0; i < matchPositions.length; i++) {
				matches.push(matchPositions[i]);
			}
		}
	}
	// Check vertical matches
	for (var x = 0; x < gridSize; x++) {
		var count = 0;
		var currentColor = -1;
		var matchPositions = [];
		for (var y = 0; y < gridSize; y++) {
			if (!isValidGridPosition(x, y)) {
				// Invalid position, reset match counting
				if (count >= 3) {
					for (var i = 0; i < matchPositions.length; i++) {
						matches.push(matchPositions[i]);
					}
				}
				count = 0;
				currentColor = -1;
				matchPositions = [];
				continue;
			}
			var ball = grid[y][x];
			if (ball && ball.ballColor !== undefined && ball.ballColor === currentColor) {
				count++;
				matchPositions.push({
					x: x,
					y: y
				});
			} else {
				if (count >= 3) {
					for (var i = 0; i < matchPositions.length; i++) {
						matches.push(matchPositions[i]);
					}
				}
				count = ball && ball.ballColor !== undefined ? 1 : 0;
				currentColor = ball && ball.ballColor !== undefined ? ball.ballColor : -1;
				matchPositions = ball && ball.ballColor !== undefined ? [{
					x: x,
					y: y
				}] : [];
			}
		}
		if (count >= 3) {
			for (var i = 0; i < matchPositions.length; i++) {
				matches.push(matchPositions[i]);
			}
		}
	}
	// Check diagonal matches (top-left to bottom-right)
	for (var startY = 0; startY < gridSize; startY++) {
		for (var startX = 0; startX < gridSize; startX++) {
			if (!isValidGridPosition(startX, startY)) continue;
			var startBall = grid[startY][startX];
			if (!startBall || startBall.ballColor === undefined) continue;
			var count = 1;
			var currentColor = startBall.ballColor;
			var matchPositions = [{
				x: startX,
				y: startY
			}];
			for (var step = 1; startX + step < gridSize && startY + step < gridSize; step++) {
				var x = startX + step;
				var y = startY + step;
				if (!isValidGridPosition(x, y)) break;
				var ball = grid[y][x];
				if (ball && ball.ballColor === currentColor) {
					count++;
					matchPositions.push({
						x: x,
						y: y
					});
				} else {
					break;
				}
			}
			if (count >= 3) {
				for (var i = 0; i < matchPositions.length; i++) {
					matches.push(matchPositions[i]);
				}
			}
		}
	}
	// Check diagonal matches (top-right to bottom-left)
	for (var startY = 0; startY < gridSize; startY++) {
		for (var startX = gridSize - 1; startX >= 0; startX--) {
			if (!isValidGridPosition(startX, startY)) continue;
			var startBall = grid[startY][startX];
			if (!startBall || startBall.ballColor === undefined) continue;
			var count = 1;
			var currentColor = startBall.ballColor;
			var matchPositions = [{
				x: startX,
				y: startY
			}];
			for (var step = 1; startX - step >= 0 && startY + step < gridSize; step++) {
				var x = startX - step;
				var y = startY + step;
				if (!isValidGridPosition(x, y)) break;
				var ball = grid[y][x];
				if (ball && ball.ballColor === currentColor) {
					count++;
					matchPositions.push({
						x: x,
						y: y
					});
				} else {
					break;
				}
			}
			if (count >= 3) {
				for (var i = 0; i < matchPositions.length; i++) {
					matches.push(matchPositions[i]);
				}
			}
		}
	}
	return matches;
}
function removeMatches() {
	var matches = findMatches();
	if (matches.length === 0) {
		return false;
	}
	var pointsEarned = matches.length * 10;
	// Check if this is a 4-ball match for special rewards
	var isFourBallMatch = matches.length === 4;
	if (isFourBallMatch) {
		// Award bonus 10 points for 4-ball match
		pointsEarned += 10;
	}
	for (var i = 0; i < matches.length; i++) {
		var match = matches[i];
		var ball = grid[match.y][match.x];
		if (ball) {
			// If it's a chained ball, break the chain first then explode
			if (ball.isChained) {
				ball.breakChain();
				// Give extra points for breaking chains
				pointsEarned += 5;
			}
			ball.explode();
			grid[match.y][match.x] = null;
		}
	}
	LK.setScore(LK.getScore() + pointsEarned);
	scoreText.setText('Score: ' + LK.getScore());
	// Update progress bar
	var currentScore = LK.getScore();
	var progress = Math.min(1, currentScore % 400 / 400);
	progressBarFill.width = progress * 400;
	progressText.setText(currentScore % 400 + '/400');
	// Spawn a bomb as reward for 4-ball match
	if (isFourBallMatch) {
		// Find a random empty valid position to place the bomb
		var emptyPositions = [];
		for (var y = 0; y < gridSize; y++) {
			for (var x = 0; x < gridSize; x++) {
				if (grid[y][x] === null && isValidGridPosition(x, y)) {
					emptyPositions.push({
						x: x,
						y: y
					});
				}
			}
		}
		if (emptyPositions.length > 0) {
			var randomPos = emptyPositions[Math.floor(Math.random() * emptyPositions.length)];
			var rewardBomb = new Bomb();
			rewardBomb.setGridPosition(randomPos.x, randomPos.y);
			grid[randomPos.y][randomPos.x] = rewardBomb;
			game.addChild(rewardBomb);
			// Animate bomb appearing with special effect
			rewardBomb.scaleX = 0;
			rewardBomb.scaleY = 0;
			rewardBomb.alpha = 0;
			tween(rewardBomb, {
				scaleX: 1.2,
				scaleY: 1.2,
				alpha: 1
			}, {
				duration: 600,
				easing: tween.easeOut,
				onFinish: function onFinish() {
					tween(rewardBomb, {
						scaleX: 0.8,
						scaleY: 0.8
					}, {
						duration: 200,
						easing: tween.easeOut
					});
				}
			});
			// Flash screen gold to indicate bomb reward
			LK.effects.flashScreen(0xFFD700, 500);
		}
	}
	LK.getSound('match').play();
	checkLevelProgression();
	return true;
}
function dropBalls() {
	for (var x = 0; x < gridSize; x++) {
		var writePos = gridSize - 1;
		// Find the lowest valid position for this column
		while (writePos >= 0 && !isValidGridPosition(x, writePos)) {
			writePos--;
		}
		for (var y = gridSize - 1; y >= 0; y--) {
			if (grid[y][x] !== null && isValidGridPosition(x, y)) {
				if (y !== writePos && writePos >= 0) {
					grid[writePos][x] = grid[y][x];
					grid[y][x] = null;
					var ball = grid[writePos][x];
					if (ball) {
						ball.isAnimating = true;
						var oldY = ball.y;
						ball.setGridPosition(x, writePos);
						var newY = ball.y;
						ball.y = oldY;
						// Animate ball falling down
						(function (ballToAnimate) {
							tween(ballToAnimate, {
								y: newY
							}, {
								duration: 300,
								easing: tween.easeOut,
								onFinish: function onFinish() {
									ballToAnimate.isAnimating = false;
								}
							});
						})(ball);
					}
				}
				writePos--;
				// Find next valid position
				while (writePos >= 0 && !isValidGridPosition(x, writePos)) {
					writePos--;
				}
			}
		}
	}
}
function fillEmptySpaces() {
	for (var x = 0; x < gridSize; x++) {
		for (var y = 0; y < gridSize; y++) {
			if (grid[y][x] === null && isValidGridPosition(x, y)) {
				createBallAt(x, y);
			}
		}
	}
}
function processMatches() {
	if (isProcessingMatches) {
		return;
	}
	isProcessingMatches = true;
	function processStep() {
		if (removeMatches()) {
			dropBalls();
			fillEmptySpaces();
			LK.setTimeout(function () {
				processStep();
			}, 500);
		} else {
			isProcessingMatches = false;
			checkGameState();
		}
	}
	processStep();
}
function checkLevelProgression() {
	var newLevel = Math.floor(LK.getScore() / 400) + 1;
	if (newLevel > currentLevel) {
		// Level up!
		currentLevel = newLevel;
		pointsToNextLevel = currentLevel * 400; // Every 400 points
		// Increase difficulty
		if (ballColors < 6) {
			ballColors = Math.min(6, 3 + currentLevel); // Max 6 colors
		}
		// Give bonus moves for leveling up, but fewer as levels increase
		var bonusMoves = Math.max(8, 20 - currentLevel);
		movesLeft += bonusMoves;
		// Update UI
		movesText.setText('Moves: ' + movesLeft);
		// Reset progress bar for new level
		var currentScore = LK.getScore();
		var progress = Math.min(1, currentScore % 400 / 400);
		progressBarFill.width = progress * 400;
		progressText.setText(currentScore % 400 + '/400');
		// Change grid shape for new level - clear existing balls first
		for (var y = 0; y < gridSize; y++) {
			for (var x = 0; x < gridSize; x++) {
				if (grid[y][x]) {
					grid[y][x].destroy();
					grid[y][x] = null;
				}
			}
		}
		// Initialize new grid shape
		gridShape = getCurrentGridShape();
		// Fill new shape with balls
		for (var y = 0; y < gridSize; y++) {
			for (var x = 0; x < gridSize; x++) {
				if (isValidGridPosition(x, y)) {
					createBallAt(x, y);
				}
			}
		}
		// Flash screen green for level up
		LK.effects.flashScreen(0x00FF00, 800);
	}
}
function checkGameState() {
	checkLevelProgression();
	if (movesLeft <= 0) {
		LK.showGameOver();
		return;
	}
}
function getClickedBall(x, y) {
	var gridX = Math.floor((x - gridStartX) / cellSize);
	var gridY = Math.floor((y - gridStartY) / cellSize);
	if (gridX >= 0 && gridX < gridSize && gridY >= 0 && gridY < gridSize) {
		return getBallAt(gridX, gridY);
	}
	return null;
}
game.down = function (x, y, obj) {
	if (isProcessingMatches) {
		return;
	}
	var clickedBall = getClickedBall(x, y);
	if (clickedBall && !clickedBall.isAnimating) {
		// Check if it's a health box
		if (clickedBall.isHealthBox) {
			clickedBall.activateHealthBonus();
			return;
		}
		// Check if it's a bomb
		if (clickedBall.isBomb) {
			draggedBomb = clickedBall;
			draggedBomb.isDragging = true;
			// Stop pulsing animation
			tween.stop(draggedBomb);
			// Make bomb slightly larger while dragging
			tween(draggedBomb, {
				scaleX: 1.0,
				scaleY: 1.0
			}, {
				duration: 100,
				easing: tween.easeOut
			});
			return;
		}
		// Regular ball logic
		if (selectedBall === null) {
			selectedBall = clickedBall;
			LK.effects.flashObject(selectedBall, 0xffffff, 200);
		} else if (selectedBall === clickedBall) {
			selectedBall = null;
		} else {
			if (swapBalls(selectedBall, clickedBall)) {
				movesLeft--;
				movesText.setText('Moves: ' + movesLeft);
				LK.setTimeout(function () {
					var matches = findMatches();
					if (matches.length > 0) {
						processMatches();
					} else {
						// Wasted move - swap back and apply additional penalty
						swapBalls(selectedBall, clickedBall);
						// No additional penalty for wasted move (already lost 1 move from the attempt)
						movesText.setText('Moves: ' + movesLeft);
						// Flash screen red to indicate wasted move
						LK.effects.flashScreen(0xFF0000, 300);
					}
				}, 300);
			}
			selectedBall = null;
		}
	}
};
game.move = function (x, y, obj) {
	if (draggedBomb && Date.now() - lastMoveTime > 16) {
		// Throttle to ~60fps
		draggedBomb.x = x;
		draggedBomb.y = y;
		lastMoveTime = Date.now();
	}
};
game.up = function (x, y, obj) {
	if (draggedBomb) {
		// Explode bomb at current position
		draggedBomb.explode3x3();
		// Using a bomb costs 2 moves
		movesLeft -= 2;
		movesText.setText('Moves: ' + movesLeft);
		// Process any resulting matches
		LK.setTimeout(function () {
			dropBalls();
			fillEmptySpaces();
			processMatches();
		}, 100);
		draggedBomb = null;
	}
};
// Add background
var backgroundImage = game.attachAsset('background', {
	anchorX: 0,
	anchorY: 0,
	x: 0,
	y: 0,
	alpha: 0.3
});
// Initialize the game
initializeGrid();
// Reset button for swapping balls
var resetButton = LK.getAsset('gridCell', {
	width: 200,
	height: 80,
	anchorX: 0.5,
	anchorY: 0.5,
	color: 0xFF6B6B
});
LK.gui.bottom.addChild(resetButton);
resetButton.y = -100;
var resetButtonText = new Text2('RESET', {
	size: 40,
	fill: 0xFFFFFF
});
resetButtonText.anchor.set(0.5, 0.5);
resetButton.addChild(resetButtonText);
resetButton.down = function (x, y, obj) {
	if (isProcessingMatches) {
		return;
	}
	// Check if player has enough score to reset (cost 100 points)
	var resetCost = 100;
	if (LK.getScore() < resetCost) {
		// Flash screen red to indicate insufficient score
		LK.effects.flashScreen(0xFF0000, 400);
		return;
	}
	// Clear current selection
	selectedBall = null;
	// Clear the grid
	for (var y = 0; y < gridSize; y++) {
		for (var x = 0; x < gridSize; x++) {
			if (grid[y][x]) {
				grid[y][x].destroy();
				grid[y][x] = null;
			}
		}
	}
	// Reinitialize the grid with new balls
	initializeGrid();
	// Cost 100 score points to reset
	LK.setScore(LK.getScore() - resetCost);
	scoreText.setText('Score: ' + LK.getScore());
	// Update progress bar
	var currentScore = LK.getScore();
	var progress = Math.min(1, currentScore % 400 / 400);
	progressBarFill.width = progress * 400;
	progressText.setText(currentScore % 400 + '/400');
	// Flash screen blue to indicate reset
	LK.effects.flashScreen(0x0066FF, 400);
};
// Play background music
LK.playMusic('Ana');
;
;

===================================================================
--- original.js
+++ change.js
@@ -308,10 +308,10 @@
 			}
 		});
 	};
 	self.activateHealthBonus = function () {
-		// Add 5 moves when health box is clicked
-		movesLeft += 5;
+		// Add 8 moves when health box is clicked
+		movesLeft += 8;
 		movesText.setText('Moves: ' + movesLeft);
 		// Remove health box from grid
 		grid[self.gridY][self.gridX] = null;
 		// Visual effect for health box activation
@@ -438,21 +438,21 @@
 function isValidGridPosition(x, y) {
 	return gridShape[y] && gridShape[y][x];
 }
 var selectedBall = null;
-var movesLeft = 30;
+var movesLeft = 40;
 var isProcessingMatches = false;
 var ballColors = 4; // Start with 4 colors for easier beginning
-var bombSpawnChance = 0.02; // 2% chance to spawn bomb instead of ball
-var healthBoxSpawnChance = 0.02; // 2% chance to spawn health box instead of ball
+var bombSpawnChance = 0.01; // 1% chance to spawn bomb instead of ball
+var healthBoxSpawnChance = 0.04; // 4% chance to spawn health box instead of ball
 var draggedBomb = null;
 var lastMoveTime = 0;
 var currentLevel = 1;
 var baseMovesPerLevel = 30;
 var pointsToNextLevel = 400; // Points needed to advance to next level
 var totalPointsEarned = 0;
 // UI Elements
-var movesText = new Text2('Moves: 30', {
+var movesText = new Text2('Moves: 40', {
 	size: 80,
 	fill: 0xFFFFFF
 });
 movesText.anchor.set(0.5, 0);
@@ -1004,9 +1004,9 @@
 		if (ballColors < 6) {
 			ballColors = Math.min(6, 3 + currentLevel); // Max 6 colors
 		}
 		// Give bonus moves for leveling up, but fewer as levels increase
-		var bonusMoves = Math.max(5, 15 - currentLevel);
+		var bonusMoves = Math.max(8, 20 - currentLevel);
 		movesLeft += bonusMoves;
 		// Update UI
 		movesText.setText('Moves: ' + movesLeft);
 		// Reset progress bar for new level
@@ -1095,10 +1095,9 @@
 						processMatches();
 					} else {
 						// Wasted move - swap back and apply additional penalty
 						swapBalls(selectedBall, clickedBall);
-						// Additional penalty for wasted move
-						movesLeft -= 1; // Lose 1 extra move for wasted attempt
+						// No additional penalty for wasted move (already lost 1 move from the attempt)
 						movesText.setText('Moves: ' + movesLeft);
 						// Flash screen red to indicate wasted move
 						LK.effects.flashScreen(0xFF0000, 300);
 					}
@@ -1119,10 +1118,10 @@
 game.up = function (x, y, obj) {
 	if (draggedBomb) {
 		// Explode bomb at current position
 		draggedBomb.explode3x3();
-		// Using a bomb costs 3 moves
-		movesLeft -= 3;
+		// Using a bomb costs 2 moves
+		movesLeft -= 2;
 		movesText.setText('Moves: ' + movesLeft);
 		// Process any resulting matches
 		LK.setTimeout(function () {
 			dropBalls();