/**** 
* 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 a red box with some visual effects
	var bombGraphics = self.attachAsset('gridCell', {
		anchorX: 0.5,
		anchorY: 0.5,
		scaleX: 0.8,
		scaleY: 0.8
	});
	bombGraphics.tint = 0xFF0000;
	// 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.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) {
						ball.explode();
						grid[targetY][targetX] = null;
						explodedCount++;
					}
				}
			}
		}
		// Award points for exploded balls
		LK.setScore(LK.getScore() + explodedCount * 15);
		scoreText.setText('Score: ' + LK.getScore());
		// 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;
});

/**** 
* 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 selectedBall = null;
var movesLeft = 30;
var targetScore = 1000;
var isProcessingMatches = false;
var ballColors = 6;
var bombSpawnChance = 0.05; // 5% chance to spawn bomb instead of ball
var draggedBomb = null;
var lastMoveTime = 0;
// UI Elements
var movesText = new Text2('Moves: 30', {
	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.5, 0);
LK.gui.top.addChild(scoreText);
scoreText.y = 250;
var targetText = new Text2('Target: 1000', {
	size: 60,
	fill: 0xFFFF00
});
targetText.anchor.set(0.5, 0);
LK.gui.top.addChild(targetText);
targetText.y = 340;
// Initialize grid
function initializeGrid() {
	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
	for (var y = 0; y < gridSize; y++) {
		for (var x = 0; x < gridSize; x++) {
			createBallAt(x, y);
		}
	}
	// Remove initial matches
	while (findMatches().length > 0) {
		removeMatches();
		dropBalls();
		fillEmptySpaces();
	}
}
function createBallAt(x, y) {
	// 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 {
		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;
	}
	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 = 1;
		var currentColor = grid[y][0] ? grid[y][0].ballColor : -1;
		for (var x = 1; x < gridSize; x++) {
			var ball = grid[y][x];
			if (ball && ball.ballColor === currentColor) {
				count++;
			} else {
				if (count >= 3) {
					for (var i = x - count; i < x; i++) {
						matches.push({
							x: i,
							y: y
						});
					}
				}
				count = 1;
				currentColor = ball ? ball.ballColor : -1;
			}
		}
		if (count >= 3) {
			for (var i = gridSize - count; i < gridSize; i++) {
				matches.push({
					x: i,
					y: y
				});
			}
		}
	}
	// Check vertical matches
	for (var x = 0; x < gridSize; x++) {
		var count = 1;
		var currentColor = grid[0][x] ? grid[0][x].ballColor : -1;
		for (var y = 1; y < gridSize; y++) {
			var ball = grid[y][x];
			if (ball && ball.ballColor === currentColor) {
				count++;
			} else {
				if (count >= 3) {
					for (var i = y - count; i < y; i++) {
						matches.push({
							x: x,
							y: i
						});
					}
				}
				count = 1;
				currentColor = ball ? ball.ballColor : -1;
			}
		}
		if (count >= 3) {
			for (var i = gridSize - count; i < gridSize; i++) {
				matches.push({
					x: x,
					y: i
				});
			}
		}
	}
	return matches;
}
function removeMatches() {
	var matches = findMatches();
	if (matches.length === 0) {
		return false;
	}
	var pointsEarned = matches.length * 10;
	for (var i = 0; i < matches.length; i++) {
		var match = matches[i];
		var ball = grid[match.y][match.x];
		if (ball) {
			ball.explode();
			grid[match.y][match.x] = null;
		}
	}
	LK.setScore(LK.getScore() + pointsEarned);
	scoreText.setText('Score: ' + LK.getScore());
	LK.getSound('match').play();
	return true;
}
function dropBalls() {
	for (var x = 0; x < gridSize; x++) {
		var writePos = gridSize - 1;
		for (var y = gridSize - 1; y >= 0; y--) {
			if (grid[y][x] !== null) {
				if (y !== writePos) {
					grid[writePos][x] = grid[y][x];
					grid[y][x] = null;
					var ball = grid[writePos][x];
					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--;
			}
		}
	}
}
function fillEmptySpaces() {
	for (var x = 0; x < gridSize; x++) {
		for (var y = 0; y < gridSize; y++) {
			if (grid[y][x] === null) {
				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 checkGameState() {
	if (LK.getScore() >= targetScore) {
		LK.showYouWin();
		return;
	}
	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 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 {
						swapBalls(selectedBall, clickedBall);
						movesLeft++;
						movesText.setText('Moves: ' + movesLeft);
					}
				}, 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();
		// Process any resulting matches
		LK.setTimeout(function () {
			dropBalls();
			fillEmptySpaces();
			processMatches();
		}, 100);
		draggedBomb = null;
	}
};
// Initialize the game
initializeGrid();
;

===================================================================
--- original.js
+++ change.js
@@ -41,8 +41,96 @@
 		});
 	};
 	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 a red box with some visual effects
+	var bombGraphics = self.attachAsset('gridCell', {
+		anchorX: 0.5,
+		anchorY: 0.5,
+		scaleX: 0.8,
+		scaleY: 0.8
+	});
+	bombGraphics.tint = 0xFF0000;
+	// 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.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) {
+						ball.explode();
+						grid[targetY][targetX] = null;
+						explodedCount++;
+					}
+				}
+			}
+		}
+		// Award points for exploded balls
+		LK.setScore(LK.getScore() + explodedCount * 15);
+		scoreText.setText('Score: ' + LK.getScore());
+		// 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;
+});
 
 /**** 
 * Initialize Game
 ****/ 
@@ -63,8 +151,11 @@
 var movesLeft = 30;
 var targetScore = 1000;
 var isProcessingMatches = false;
 var ballColors = 6;
+var bombSpawnChance = 0.05; // 5% chance to spawn bomb instead of ball
+var draggedBomb = null;
+var lastMoveTime = 0;
 // UI Elements
 var movesText = new Text2('Moves: 30', {
 	size: 80,
 	fill: 0xFFFFFF
@@ -108,26 +199,47 @@
 		fillEmptySpaces();
 	}
 }
 function createBallAt(x, y) {
-	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;
+	// 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 {
+		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;
@@ -362,8 +474,25 @@
 		return;
 	}
 	var clickedBall = getClickedBall(x, y);
 	if (clickedBall && !clickedBall.isAnimating) {
+		// 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) {
@@ -386,8 +515,28 @@
 			selectedBall = null;
 		}
 	}
 };
-game.up = function (x, y, obj) {};
+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();
+		// Process any resulting matches
+		LK.setTimeout(function () {
+			dropBalls();
+			fillEmptySpaces();
+			processMatches();
+		}, 100);
+		draggedBomb = null;
+	}
+};
 // Initialize the game
 initializeGrid();
 ;
\ No newline at end of file