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

/**** 
* Classes
****/ 
var Block = Container.expand(function (color) {
	var self = Container.call(this);
	self.color = color || 'red';
	self.gridX = -1;
	self.gridY = -1;
	self.isEmpty = false;
	// Color mapping
	var colorAssets = {
		'red': 'face_red',
		'blue': 'face_blue',
		'green': 'face_green',
		'yellow': 'face_yellow',
		'white': 'face_white',
		'rainbow': 'face_rainbow'
	};
	var assetName = colorAssets[self.color] || 'face_red';
	var blockGraphics = self.attachAsset(assetName, {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.setColor = function (newColor) {
		self.color = newColor;
		self.removeChild(blockGraphics);
		var newAssetName = colorAssets[newColor] || 'face_red';
		blockGraphics = self.attachAsset(newAssetName, {
			anchorX: 0.5,
			anchorY: 0.5
		});
	};
	return self;
});
var Grid = Container.expand(function () {
	var self = Container.call(this);
	self.gridWidth = 7;
	self.gridHeight = 9;
	self.cellSize = 80;
	self.cells = [];
	// Initialize empty grid
	for (var y = 0; y < self.gridHeight; y++) {
		self.cells[y] = [];
		for (var x = 0; x < self.gridWidth; x++) {
			self.cells[y][x] = null;
		}
	}
	// Draw grid background
	for (var y = 0; y < self.gridHeight; y++) {
		for (var x = 0; x < self.gridWidth; x++) {
			var cell = self.attachAsset('block_gray', {
				anchorX: 0.5,
				anchorY: 0.5,
				x: x * self.cellSize,
				y: y * self.cellSize,
				alpha: 0.3
			});
		}
	}
	self.isValidPosition = function (gridX, gridY) {
		return gridX >= 0 && gridX < self.gridWidth && gridY >= 0 && gridY < self.gridHeight;
	};
	self.isEmpty = function (gridX, gridY) {
		if (!self.isValidPosition(gridX, gridY)) return false;
		return self.cells[gridY][gridX] === null;
	};
	self.placeBlock = function (block, gridX, gridY) {
		if (!self.isEmpty(gridX, gridY)) return false;
		self.cells[gridY][gridX] = block;
		block.gridX = gridX;
		block.gridY = gridY;
		block.x = gridX * self.cellSize;
		block.y = gridY * self.cellSize;
		return true;
	};
	self.removeBlock = function (gridX, gridY) {
		if (!self.isValidPosition(gridX, gridY)) return null;
		var block = self.cells[gridY][gridX];
		if (block) {
			self.cells[gridY][gridX] = null;
			block.gridX = -1;
			block.gridY = -1;
		}
		return block;
	};
	self.getBlock = function (gridX, gridY) {
		if (!self.isValidPosition(gridX, gridY)) return null;
		return self.cells[gridY][gridX];
	};
	self.worldToGrid = function (worldX, worldY) {
		var localPos = self.toLocal({
			x: worldX,
			y: worldY
		});
		var gridX = Math.floor((localPos.x + self.cellSize / 2) / self.cellSize);
		var gridY = Math.floor((localPos.y + self.cellSize / 2) / self.cellSize);
		return {
			x: gridX,
			y: gridY
		};
	};
	self.findConnectedBlocks = function (startX, startY, color, visited) {
		if (!visited) visited = [];
		var block = self.getBlock(startX, startY);
		if (!block || block.color !== color) return [];
		var key = startX + ',' + startY;
		if (visited.indexOf(key) !== -1) return [];
		visited.push(key);
		var connected = [{
			x: startX,
			y: startY
		}];
		// Check 4 directions
		var directions = [{
			x: 0,
			y: -1
		}, {
			x: 1,
			y: 0
		}, {
			x: 0,
			y: 1
		}, {
			x: -1,
			y: 0
		}];
		for (var i = 0; i < directions.length; i++) {
			var dir = directions[i];
			var newX = startX + dir.x;
			var newY = startY + dir.y;
			var moreConnected = self.findConnectedBlocks(newX, newY, color, visited);
			connected = connected.concat(moreConnected);
		}
		return connected;
	};
	self.checkForMerges = function () {
		var toMerge = [];
		var processed = [];
		for (var y = 0; y < self.gridHeight; y++) {
			for (var x = 0; x < self.gridWidth; x++) {
				var key = x + ',' + y;
				if (processed.indexOf(key) !== -1) continue;
				var block = self.getBlock(x, y);
				if (!block) continue;
				var connected = self.findConnectedBlocks(x, y, block.color, []);
				for (var i = 0; i < connected.length; i++) {
					var pos = connected[i];
					processed.push(pos.x + ',' + pos.y);
				}
				if (connected.length >= 3) {
					toMerge.push(connected);
				}
			}
		}
		return toMerge;
	};
	self.performMerges = function (mergeGroups) {
		var totalScore = 0;
		for (var i = 0; i < mergeGroups.length; i++) {
			var group = mergeGroups[i];
			var score = group.length * 10;
			totalScore += score;
			// Find center position for new block
			var centerX = 0,
				centerY = 0;
			for (var j = 0; j < group.length; j++) {
				centerX += group[j].x;
				centerY += group[j].y;
			}
			centerX = Math.floor(centerX / group.length);
			centerY = Math.floor(centerY / group.length);
			// Get color before removing blocks
			var firstBlock = self.getBlock(group[0].x, group[0].y);
			var currentColor = firstBlock ? firstBlock.color : 'red';
			var nextColor = self.getNextColor(currentColor);
			// Remove all blocks in group
			for (var j = 0; j < group.length; j++) {
				var pos = group[j];
				var block = self.removeBlock(pos.x, pos.y);
				if (block) {
					block.destroy();
				}
			}
			if (self.isEmpty(centerX, centerY)) {
				var newBlock = new Block(nextColor);
				game.addChild(newBlock);
				self.placeBlock(newBlock, centerX, centerY);
			}
		}
		return totalScore;
	};
	self.getNextColor = function (color) {
		var colorSequence = ['red', 'blue', 'green', 'yellow', 'white', 'rainbow'];
		var index = colorSequence.indexOf(color);
		if (index === -1 || index === colorSequence.length - 1) {
			return 'red';
		}
		return colorSequence[index + 1];
	};
	self.isFull = function () {
		for (var y = 0; y < self.gridHeight; y++) {
			for (var x = 0; x < self.gridWidth; x++) {
				if (self.isEmpty(x, y)) return false;
			}
		}
		return true;
	};
	return self;
});

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

/**** 
* Game Code
****/ 
// Game state variables
var gameGrid;
var currentBlock;
var draggedBlock = null;
var colors = ['red', 'blue', 'green', 'yellow'];
var isProcessingMerges = false;
// UI elements
var scoreTxt = new Text2('Score: 0', {
	size: 60,
	fill: 0xFFFFFF
});
scoreTxt.anchor.set(0.5, 0);
LK.gui.top.addChild(scoreTxt);
var nextBlockTxt = new Text2('Next Block:', {
	size: 40,
	fill: 0xFFFFFF
});
nextBlockTxt.anchor.set(0, 0);
nextBlockTxt.x = 50;
nextBlockTxt.y = 150;
LK.gui.topLeft.addChild(nextBlockTxt);
// Initialize grid
gameGrid = new Grid();
gameGrid.x = (2048 - (gameGrid.gridWidth - 1) * gameGrid.cellSize) / 2;
gameGrid.y = (2732 - (gameGrid.gridHeight - 1) * gameGrid.cellSize) / 2;
game.addChild(gameGrid);
// Create first block
function createNewBlock() {
	if (currentBlock) {
		currentBlock.destroy();
	}
	var randomColor = colors[Math.floor(Math.random() * colors.length)];
	currentBlock = new Block(randomColor);
	currentBlock.x = 2048 / 2;
	currentBlock.y = 150;
	game.addChild(currentBlock);
	// Check if game is over
	if (gameGrid.isFull()) {
		LK.showGameOver();
	}
}
// Game input handling
game.down = function (x, y, obj) {
	if (isProcessingMerges) return;
	// Simple distance-based check for touching the current block
	if (currentBlock) {
		var dx = x - currentBlock.x;
		var dy = y - currentBlock.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		if (distance < 50) {
			// Touch radius
			draggedBlock = currentBlock;
		}
	}
};
game.move = function (x, y, obj) {
	if (draggedBlock && !isProcessingMerges) {
		draggedBlock.x = x;
		draggedBlock.y = y;
	}
};
game.up = function (x, y, obj) {
	if (draggedBlock && !isProcessingMerges) {
		var gridPos = gameGrid.worldToGrid(x, y);
		if (gameGrid.isEmpty(gridPos.x, gridPos.y)) {
			// Place block on grid
			if (gameGrid.placeBlock(draggedBlock, gridPos.x, gridPos.y)) {
				draggedBlock = null;
				currentBlock = null;
				// Check for merges
				processMerges();
			} else {
				// Return block to original position
				draggedBlock.x = 2048 / 2;
				draggedBlock.y = 150;
			}
		} else {
			// Return block to original position
			draggedBlock.x = 2048 / 2;
			draggedBlock.y = 150;
		}
	}
	draggedBlock = null;
};
function processMerges() {
	isProcessingMerges = true;
	function checkMerges() {
		var mergeGroups = gameGrid.checkForMerges();
		if (mergeGroups.length > 0) {
			var score = gameGrid.performMerges(mergeGroups);
			LK.setScore(LK.getScore() + score);
			scoreTxt.setText('Score: ' + LK.getScore());
			// Flash screen for satisfying feedback
			LK.effects.flashScreen(0x00ff00, 300);
			// Check for more merges after a short delay
			LK.setTimeout(checkMerges, 500);
		} else {
			// No more merges, create new block
			isProcessingMerges = false;
			createNewBlock();
		}
	}
	checkMerges();
}
// Update score display
scoreTxt.setText('Score: ' + LK.getScore());
// Create initial block
createNewBlock();

===================================================================
--- original.js
+++ change.js
@@ -173,20 +173,20 @@
 				centerY += group[j].y;
 			}
 			centerX = Math.floor(centerX / group.length);
 			centerY = Math.floor(centerY / group.length);
+			// Get color before removing blocks
+			var firstBlock = self.getBlock(group[0].x, group[0].y);
+			var currentColor = firstBlock ? firstBlock.color : 'red';
+			var nextColor = self.getNextColor(currentColor);
 			// Remove all blocks in group
 			for (var j = 0; j < group.length; j++) {
 				var pos = group[j];
 				var block = self.removeBlock(pos.x, pos.y);
 				if (block) {
 					block.destroy();
 				}
 			}
-			// Create new block with next color
-			var firstBlock = self.getBlock(group[0].x, group[0].y);
-			var currentColor = firstBlock ? firstBlock.color : 'red';
-			var nextColor = self.getNextColor(currentColor);
 			if (self.isEmpty(centerX, centerY)) {
 				var newBlock = new Block(nextColor);
 				game.addChild(newBlock);
 				self.placeBlock(newBlock, centerX, centerY);
@@ -267,15 +267,17 @@
 }
 // Game input handling
 game.down = function (x, y, obj) {
 	if (isProcessingMerges) return;
-	if (currentBlock && currentBlock.intersects({
-		x: x,
-		y: y,
-		width: 1,
-		height: 1
-	})) {
-		draggedBlock = currentBlock;
+	// Simple distance-based check for touching the current block
+	if (currentBlock) {
+		var dx = x - currentBlock.x;
+		var dy = y - currentBlock.y;
+		var distance = Math.sqrt(dx * dx + dy * dy);
+		if (distance < 50) {
+			// Touch radius
+			draggedBlock = currentBlock;
+		}
 	}
 };
 game.move = function (x, y, obj) {
 	if (draggedBlock && !isProcessingMerges) {