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

/**** 
* Classes
****/ 
var Candy = Container.expand(function (type, row, col) {
	var self = Container.call(this);
	self.type = type;
	self.row = row;
	self.col = col;
	self.isSpecial = false;
	self.specialType = null;
	self.matchCount = 0;
	var assetMap = {
		'blue': 'blueCandy',
		'red': 'redCandy',
		'green': 'greenCandy',
		'orange': 'orangeCandy',
		'purple': 'purpleCandy'
	};
	var specialAssetMap = {
		'blueBomb': 'blueBomb',
		'redRocket': 'redRocket',
		'greenPentagon': 'greenPentagon',
		'orangeLollipop': 'orangeLollipop',
		'purpleBerry': 'purpleBerry',
		'discoBall': 'discoBall'
	};
	self.graphics = self.attachAsset(assetMap[type], {
		anchorX: 0.5,
		anchorY: 0.5,
		scaleX: 0.8,
		scaleY: 0.8
	});
	self.makeSpecial = function (specialType) {
		self.isSpecial = true;
		self.specialType = specialType;
		self.removeChild(self.graphics);
		self.graphics = self.attachAsset(specialAssetMap[specialType], {
			anchorX: 0.5,
			anchorY: 0.5,
			scaleX: 0.8,
			scaleY: 0.8
		});
	};
	self.explode = function () {
		tween(self, {
			scaleX: 1.5,
			scaleY: 1.5,
			alpha: 0
		}, {
			duration: 300,
			easing: tween.easeOut,
			onFinish: function onFinish() {
				if (self.parent) {
					self.parent.removeChild(self);
				}
			}
		});
	};
	return self;
});
var StarField = Container.expand(function () {
	var self = Container.call(this);
	var stars = [];
	var numStars = 100;
	// Create individual stars
	for (var i = 0; i < numStars; i++) {
		var star = LK.getAsset('gridLine', {
			width: Math.random() * 6 + 2,
			height: Math.random() * 6 + 2,
			color: 0xFFFFFF,
			shape: 'ellipse',
			anchorX: 0.5,
			anchorY: 0.5,
			x: Math.random() * 2048,
			y: Math.random() * 2732,
			alpha: Math.random() * 0.8 + 0.2
		});
		self.addChild(star);
		stars.push(star);
		// Start twinkling animation for each star
		self.twinkle(star);
	}
	self.twinkle = function (star) {
		var targetAlpha = Math.random() * 0.8 + 0.2;
		var duration = Math.random() * 2000 + 1000;
		tween(star, {
			alpha: targetAlpha
		}, {
			duration: duration,
			easing: tween.easeInOut,
			onFinish: function onFinish() {
				self.twinkle(star);
			}
		});
	};
	return self;
});

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

/**** 
* Game Code
****/ 
var GRID_SIZE = 8;
var CELL_SIZE = 200;
var GRID_START_X = 224;
var GRID_START_Y = 566;
var COLORS = ['blue', 'red', 'green', 'orange', 'purple'];
var grid = [];
var selectedCandy = null;
var score = 0;
var level = 1;
var gold = 0;
var isProcessing = false;
var comboMultiplier = 1;
// Create animated starfield background
var starField = new StarField();
game.addChild(starField);
// Create grid background
var gridBg = game.attachAsset('gridBackground', {
	anchorX: 0.5,
	anchorY: 0.5,
	x: 1024,
	y: 1366
});
// Create grid lines
for (var i = 0; i <= GRID_SIZE; i++) {
	// Vertical lines
	var verticalLine = LK.getAsset('gridLine', {
		width: 4,
		height: GRID_SIZE * CELL_SIZE,
		color: 0x000000,
		shape: 'box',
		anchorX: 0.5,
		anchorY: 0.5,
		x: GRID_START_X + i * CELL_SIZE,
		y: GRID_START_Y + GRID_SIZE * CELL_SIZE / 2
	});
	game.addChild(verticalLine);
	// Horizontal lines
	var horizontalLine = LK.getAsset('gridLine', {
		width: GRID_SIZE * CELL_SIZE,
		height: 4,
		color: 0x000000,
		shape: 'box',
		anchorX: 0.5,
		anchorY: 0.5,
		x: GRID_START_X + GRID_SIZE * CELL_SIZE / 2,
		y: GRID_START_Y + i * CELL_SIZE
	});
	game.addChild(horizontalLine);
}
// Create UI elements
var scoreText = new Text2('Score: 0', {
	size: 80,
	fill: '#FFFFFF'
});
scoreText.anchor.set(0.5, 0);
LK.gui.top.addChild(scoreText);
scoreText.y = 100;
var levelText = new Text2('Level: 1', {
	size: 60,
	fill: '#FFFFFF'
});
levelText.anchor.set(0, 0);
LK.gui.topLeft.addChild(levelText);
levelText.x = 120;
levelText.y = 100;
var goldText = new Text2('Gold: 0', {
	size: 60,
	fill: '#FFD700'
});
goldText.anchor.set(1, 0);
LK.gui.topRight.addChild(goldText);
goldText.x = -20;
goldText.y = 100;
// Initialize grid
function initializeGrid() {
	grid = [];
	for (var row = 0; row < GRID_SIZE; row++) {
		grid[row] = [];
		for (var col = 0; col < GRID_SIZE; col++) {
			var randomColor = COLORS[Math.floor(Math.random() * COLORS.length)];
			var candy = new Candy(randomColor, row, col);
			candy.x = GRID_START_X + col * CELL_SIZE + CELL_SIZE / 2;
			candy.y = GRID_START_Y + row * CELL_SIZE + CELL_SIZE / 2;
			grid[row][col] = candy;
			game.addChild(candy);
		}
	}
	// Remove initial matches
	removeInitialMatches();
}
function removeInitialMatches() {
	var hasMatches = true;
	while (hasMatches) {
		hasMatches = false;
		for (var row = 0; row < GRID_SIZE; row++) {
			for (var col = 0; col < GRID_SIZE; col++) {
				if (checkMatch(row, col).length >= 3) {
					hasMatches = true;
					var randomColor = COLORS[Math.floor(Math.random() * COLORS.length)];
					grid[row][col].type = randomColor;
					grid[row][col].removeChild(grid[row][col].graphics);
					var assetMap = {
						'blue': 'blueCandy',
						'red': 'redCandy',
						'green': 'greenCandy',
						'orange': 'orangeCandy',
						'purple': 'purpleCandy'
					};
					grid[row][col].graphics = grid[row][col].attachAsset(assetMap[randomColor], {
						anchorX: 0.5,
						anchorY: 0.5,
						scaleX: 0.8,
						scaleY: 0.8
					});
				}
			}
		}
	}
}
function getCandyAt(x, y) {
	var col = Math.floor((x - GRID_START_X) / CELL_SIZE);
	var row = Math.floor((y - GRID_START_Y) / CELL_SIZE);
	if (row >= 0 && row < GRID_SIZE && col >= 0 && col < GRID_SIZE) {
		return grid[row][col];
	}
	return null;
}
function swapCandies(candy1, candy2) {
	if (!candy1 || !candy2 || candy1 === candy2) return false;
	var row1 = candy1.row,
		col1 = candy1.col;
	var row2 = candy2.row,
		col2 = candy2.col;
	// Check if adjacent
	var dx = Math.abs(col1 - col2);
	var dy = Math.abs(row1 - row2);
	if (dx + dy !== 1) return false;
	// Swap in grid
	grid[row1][col1] = candy2;
	grid[row2][col2] = candy1;
	// Update candy properties
	candy1.row = row2;
	candy1.col = col2;
	candy2.row = row1;
	candy2.col = col1;
	// Animate swap
	tween(candy1, {
		x: GRID_START_X + col2 * CELL_SIZE + CELL_SIZE / 2,
		y: GRID_START_Y + row2 * CELL_SIZE + CELL_SIZE / 2
	}, {
		duration: 200
	});
	tween(candy2, {
		x: GRID_START_X + col1 * CELL_SIZE + CELL_SIZE / 2,
		y: GRID_START_Y + row1 * CELL_SIZE + CELL_SIZE / 2
	}, {
		duration: 200
	});
	return true;
}
function checkMatch(row, col) {
	if (!grid[row] || !grid[row][col]) return [];
	var candy = grid[row][col];
	var matches = [candy];
	var type = candy.type;
	// Check horizontal
	for (var c = col - 1; c >= 0 && grid[row][c] && grid[row][c].type === type; c--) {
		matches.unshift(grid[row][c]);
	}
	for (var c = col + 1; c < GRID_SIZE && grid[row][c] && grid[row][c].type === type; c++) {
		matches.push(grid[row][c]);
	}
	if (matches.length >= 3) return matches;
	// Check vertical
	matches = [candy];
	for (var r = row - 1; r >= 0 && grid[r][col] && grid[r][col].type === type; r--) {
		matches.unshift(grid[r][col]);
	}
	for (var r = row + 1; r < GRID_SIZE && grid[r][col] && grid[r][col].type === type; r++) {
		matches.push(grid[r][col]);
	}
	return matches.length >= 3 ? matches : [];
}
function findAllMatches() {
	var allMatches = [];
	var processed = [];
	for (var row = 0; row < GRID_SIZE; row++) {
		processed[row] = [];
		for (var col = 0; col < GRID_SIZE; col++) {
			processed[row][col] = false;
		}
	}
	for (var row = 0; row < GRID_SIZE; row++) {
		for (var col = 0; col < GRID_SIZE; col++) {
			if (!processed[row][col]) {
				var matches = checkMatch(row, col);
				if (matches.length >= 3) {
					allMatches.push(matches);
					for (var i = 0; i < matches.length; i++) {
						processed[matches[i].row][matches[i].col] = true;
					}
				}
			}
		}
	}
	return allMatches;
}
function processMatches() {
	var allMatches = findAllMatches();
	if (allMatches.length === 0) {
		comboMultiplier = 1;
		isProcessing = false;
		return;
	}
	// Process matches and create special candies
	var totalScore = 0;
	var totalGold = 0;
	for (var m = 0; m < allMatches.length; m++) {
		var matches = allMatches[m];
		var matchScore = matches.length * 10 * comboMultiplier;
		var matchGold = matches.length * 5;
		if (comboMultiplier > 1) {
			matchGold += 50; // Combo bonus
		}
		totalScore += matchScore;
		totalGold += matchGold;
		// Check for special candy creation
		if (matches.length >= 6) {
			// Create disco ball
			var centerCandy = matches[Math.floor(matches.length / 2)];
			centerCandy.makeSpecial('discoBall');
			matches.splice(Math.floor(matches.length / 2), 1);
		} else if (matches.length === 5) {
			// Create special based on color
			var centerCandy = matches[2];
			var color = centerCandy.type;
			var specialType = color + (color === 'blue' ? 'Bomb' : color === 'red' ? 'Rocket' : color === 'green' ? 'Pentagon' : color === 'orange' ? 'Lollipop' : 'Berry');
			centerCandy.makeSpecial(specialType);
			matches.splice(2, 1);
		}
		// Explode remaining matches
		for (var i = 0; i < matches.length; i++) {
			var candy = matches[i];
			grid[candy.row][candy.col] = null;
			candy.explode();
		}
	}
	score += totalScore;
	gold += totalGold;
	comboMultiplier += 5;
	// Update level
	var newLevel = Math.floor(score / 200) + 1;
	if (newLevel > level) {
		level = newLevel;
		if (level % 5 === 0) {
			gold += 4000;
		}
	}
	updateUI();
	LK.getSound('match').play();
	// Drop candies and continue processing
	LK.setTimeout(function () {
		dropCandies();
		LK.setTimeout(function () {
			processMatches();
		}, 300);
	}, 400);
}
function dropCandies() {
	for (var col = 0; col < GRID_SIZE; col++) {
		var writeRow = GRID_SIZE - 1;
		// Move existing candies down
		for (var row = GRID_SIZE - 1; row >= 0; row--) {
			if (grid[row][col] !== null) {
				if (row !== writeRow) {
					grid[writeRow][col] = grid[row][col];
					grid[row][col] = null;
					grid[writeRow][col].row = writeRow;
					tween(grid[writeRow][col], {
						y: GRID_START_Y + writeRow * CELL_SIZE + CELL_SIZE / 2
					}, {
						duration: 200
					});
				}
				writeRow--;
			}
		}
		// Create new candies for empty spaces
		for (var row = writeRow; row >= 0; row--) {
			var randomColor = COLORS[Math.floor(Math.random() * COLORS.length)];
			var candy = new Candy(randomColor, row, col);
			candy.x = GRID_START_X + col * CELL_SIZE + CELL_SIZE / 2;
			candy.y = GRID_START_Y + (row - GRID_SIZE) * CELL_SIZE + CELL_SIZE / 2;
			grid[row][col] = candy;
			game.addChild(candy);
			tween(candy, {
				y: GRID_START_Y + row * CELL_SIZE + CELL_SIZE / 2
			}, {
				duration: 300
			});
		}
	}
}
function updateUI() {
	scoreText.setText('Score: ' + score);
	levelText.setText('Level: ' + level);
	goldText.setText('Gold: ' + gold);
}
function activateSpecialCandy(candy) {
	if (!candy.isSpecial) return;
	var row = candy.row;
	var col = candy.col;
	switch (candy.specialType) {
		case 'blueBomb':
			// Destroy 3x3 area
			for (var r = Math.max(0, row - 1); r <= Math.min(GRID_SIZE - 1, row + 1); r++) {
				for (var c = Math.max(0, col - 1); c <= Math.min(GRID_SIZE - 1, col + 1); c++) {
					if (grid[r][c] && grid[r][c] !== candy) {
						grid[r][c].explode();
						grid[r][c] = null;
					}
				}
			}
			break;
		case 'redRocket':
			// Clear entire row and column
			for (var c = 0; c < GRID_SIZE; c++) {
				if (grid[row][c] && grid[row][c] !== candy) {
					grid[row][c].explode();
					grid[row][c] = null;
				}
			}
			for (var r = 0; r < GRID_SIZE; r++) {
				if (grid[r][col] && grid[r][col] !== candy) {
					grid[r][col].explode();
					grid[r][col] = null;
				}
			}
			break;
		case 'discoBall':
			// Destroy 13 random candies
			var randomCandies = [];
			for (var r = 0; r < GRID_SIZE; r++) {
				for (var c = 0; c < GRID_SIZE; c++) {
					if (grid[r][c] && grid[r][c] !== candy) {
						randomCandies.push(grid[r][c]);
					}
				}
			}
			for (var i = 0; i < Math.min(13, randomCandies.length); i++) {
				var randomIndex = Math.floor(Math.random() * randomCandies.length);
				var randomCandy = randomCandies[randomIndex];
				randomCandy.explode();
				grid[randomCandy.row][randomCandy.col] = null;
				randomCandies.splice(randomIndex, 1);
			}
			break;
	}
	candy.explode();
	grid[row][col] = null;
	LK.getSound('powerup').play();
}
game.down = function (x, y, obj) {
	if (isProcessing) return;
	var candy = getCandyAt(x, y);
	if (!candy) return;
	if (selectedCandy === null) {
		selectedCandy = candy;
		// Add white glowing border effect
		candy.graphics.tint = 0xFFFFFF; // Keep original color
		tween(candy.graphics, {
			tint: 0xFFFFFF
		}, {
			duration: 500,
			easing: tween.easeInOut,
			onFinish: function onFinish() {
				if (selectedCandy === candy) {
					tween(candy.graphics, {
						tint: 0xFFFFFF
					}, {
						duration: 500,
						easing: tween.easeInOut,
						onFinish: function onFinish() {
							if (selectedCandy === candy) {
								// Restart the glow animation
								tween(candy.graphics, {
									tint: 0xFFFFFF
								}, {
									duration: 500,
									easing: tween.easeInOut,
									onFinish: arguments.callee
								});
							}
						}
					});
				}
			}
		});
		// Create pulsing white glow effect
		tween(candy, {
			scaleX: 1.0,
			scaleY: 1.0
		}, {
			duration: 100
		});
	} else if (selectedCandy === candy) {
		// Deselect - stop glowing animation and scale back
		tween.stop(candy.graphics, {
			tint: true
		}); // Stop the glowing animation
		candy.graphics.tint = 0xFFFFFF; // Remove tint
		tween(candy, {
			scaleX: 0.8,
			scaleY: 0.8
		}, {
			duration: 100
		});
		selectedCandy = null;
	} else {
		// Check if candies are adjacent
		var dx = Math.abs(selectedCandy.col - candy.col);
		var dy = Math.abs(selectedCandy.row - candy.row);
		if (dx + dy === 1) {
			// Remove selection effects from first candy
			tween.stop(selectedCandy.graphics, {
				tint: true
			}); // Stop the glowing animation
			selectedCandy.graphics.tint = 0xFFFFFF; // Remove tint
			tween(selectedCandy, {
				scaleX: 0.8,
				scaleY: 0.8
			}, {
				duration: 100
			});
			// Try to swap
			var tempSelectedCandy = selectedCandy;
			selectedCandy = null;
			isProcessing = true;
			if (swapCandies(tempSelectedCandy, candy)) {
				LK.setTimeout(function () {
					// Check if swap creates matches
					var matches1 = checkMatch(tempSelectedCandy.row, tempSelectedCandy.col);
					var matches2 = checkMatch(candy.row, candy.col);
					if (matches1.length >= 3 || matches2.length >= 3 || tempSelectedCandy.isSpecial || candy.isSpecial) {
						// Valid move
						if (tempSelectedCandy.isSpecial) {
							activateSpecialCandy(tempSelectedCandy);
						}
						if (candy.isSpecial) {
							activateSpecialCandy(candy);
						}
						LK.setTimeout(function () {
							processMatches();
						}, 200);
					} else {
						// Invalid move, swap back with animation
						swapCandies(tempSelectedCandy, candy);
						isProcessing = false;
					}
				}, 250);
			}
		} else {
			// Not adjacent - remove selection from first candy and select new one
			tween.stop(selectedCandy.graphics, {
				tint: true
			}); // Stop the glowing animation
			selectedCandy.graphics.tint = 0xFFFFFF; // Remove tint
			tween(selectedCandy, {
				scaleX: 0.8,
				scaleY: 0.8
			}, {
				duration: 100
			});
			// Select the new candy
			selectedCandy = candy;
			// Add white glowing border effect
			candy.graphics.tint = 0xFFFFFF; // Keep original color
			tween(candy.graphics, {
				tint: 0xFFFFFF
			}, {
				duration: 500,
				easing: tween.easeInOut,
				onFinish: function onFinish() {
					if (selectedCandy === candy) {
						tween(candy.graphics, {
							tint: 0xFFFFFF
						}, {
							duration: 500,
							easing: tween.easeInOut,
							onFinish: function onFinish() {
								if (selectedCandy === candy) {
									// Restart the glow animation
									tween(candy.graphics, {
										tint: 0xFFFFFF
									}, {
										duration: 500,
										easing: tween.easeInOut,
										onFinish: arguments.callee
									});
								}
							}
						});
					}
				}
			});
			tween(candy, {
				scaleX: 1.0,
				scaleY: 1.0
			}, {
				duration: 100
			});
		}
	}
};
// Initialize the game
initializeGrid();
updateUI();
LK.playMusic('bgmusic');

===================================================================
--- original.js
+++ change.js
@@ -62,8 +62,45 @@
 		});
 	};
 	return self;
 });
+var StarField = Container.expand(function () {
+	var self = Container.call(this);
+	var stars = [];
+	var numStars = 100;
+	// Create individual stars
+	for (var i = 0; i < numStars; i++) {
+		var star = LK.getAsset('gridLine', {
+			width: Math.random() * 6 + 2,
+			height: Math.random() * 6 + 2,
+			color: 0xFFFFFF,
+			shape: 'ellipse',
+			anchorX: 0.5,
+			anchorY: 0.5,
+			x: Math.random() * 2048,
+			y: Math.random() * 2732,
+			alpha: Math.random() * 0.8 + 0.2
+		});
+		self.addChild(star);
+		stars.push(star);
+		// Start twinkling animation for each star
+		self.twinkle(star);
+	}
+	self.twinkle = function (star) {
+		var targetAlpha = Math.random() * 0.8 + 0.2;
+		var duration = Math.random() * 2000 + 1000;
+		tween(star, {
+			alpha: targetAlpha
+		}, {
+			duration: duration,
+			easing: tween.easeInOut,
+			onFinish: function onFinish() {
+				self.twinkle(star);
+			}
+		});
+	};
+	return self;
+});
 
 /**** 
 * Initialize Game
 ****/ 
@@ -85,8 +122,11 @@
 var level = 1;
 var gold = 0;
 var isProcessing = false;
 var comboMultiplier = 1;
+// Create animated starfield background
+var starField = new StarField();
+game.addChild(starField);
 // Create grid background
 var gridBg = game.attachAsset('gridBackground', {
 	anchorX: 0.5,
 	anchorY: 0.5,