===================================================================
--- original.js
+++ change.js
@@ -1,275 +1,332 @@
 /**** 
+* Plugins
+****/ 
+var tween = LK.import("@upit/tween.v1");
+
+/**** 
 * Classes
 ****/ 
-// --- Block Class ---
-var Block = Container.expand(function () {
+var Block = Container.expand(function (color) {
 	var self = Container.call(this);
-	self.colorId = null;
-	self.gridX = null;
-	self.gridY = null;
-	self.setColor = function (colorId) {
-		self.colorId = colorId;
-		if (self.asset) self.removeChild(self.asset);
-		self.asset = self.attachAsset(colorId, {
+	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
 		});
-		self.asset.width = CELL_SIZE;
-		self.asset.height = CELL_SIZE;
 	};
-	self.setGridPos = function (gx, gy) {
-		self.gridX = gx;
-		self.gridY = gy;
-		self.x = GRID_OFFSET_X + gx * CELL_SIZE + CELL_SIZE / 2;
-		self.y = GRID_OFFSET_Y + gy * CELL_SIZE + CELL_SIZE / 2;
+	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);
+			// 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);
+			}
+		}
+		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
 ****/ 
-// --- Draw Board Background ---
+// Game state variables
 var game = new LK.Game({
 	backgroundColor: 0x000000
 });
 
 /**** 
 * Game Code
 ****/ 
-// --- Game Constants ---
-var GRID_COLS = 7;
-var GRID_ROWS = 9;
-var CELL_SIZE = 200; // Each block is 200x200 px as per asset size
-var GRID_OFFSET_X = Math.floor((2048 - GRID_COLS * CELL_SIZE) / 2);
-var GRID_OFFSET_Y = Math.floor((2732 - GRID_ROWS * CELL_SIZE) / 2);
-var COLORS = [{
-	id: 'face_red',
-	next: 'face_yellow',
-	points: 10
-}, {
-	id: 'face_yellow',
-	next: 'face_green',
-	points: 20
-}, {
-	id: 'face_green',
-	next: 'face_blue',
-	points: 30
-}, {
-	id: 'face_blue',
-	next: 'face_rainbow',
-	points: 40
-}, {
-	id: 'face_rainbow',
-	next: null,
-	points: 100
-}];
-// --- Game State ---
-var grid = [];
-for (var y = 0; y < GRID_ROWS; y++) {
-	grid[y] = [];
-	for (var x = 0; x < GRID_COLS; x++) {
-		grid[y][x] = null;
-	}
-}
-var currentBlock = null;
-var dragging = false;
-var dragSprite = null;
-var dragGridX = null;
-var dragGridY = null;
-var scoreText = null;
-// --- Helper Functions ---
-function getRandomColor() {
-	var idx = Math.floor(Math.random() * 4); // Only up to face_blue for random
-	return COLORS[idx].id;
-}
-function getColorData(id) {
-	for (var i = 0; i < COLORS.length; i++) {
-		if (COLORS[i].id === id) return COLORS[i];
-	}
-	return null;
-}
-function isInsideGrid(x, y) {
-	return x >= 0 && x < GRID_COLS && y >= 0 && y < GRID_ROWS;
-}
-function getNeighbors(x, y) {
-	var n = [];
-	if (isInsideGrid(x - 1, y)) n.push({
-		x: x - 1,
-		y: y
-	});
-	if (isInsideGrid(x + 1, y)) n.push({
-		x: x + 1,
-		y: y
-	});
-	if (isInsideGrid(x, y - 1)) n.push({
-		x: x,
-		y: y - 1
-	});
-	if (isInsideGrid(x, y + 1)) n.push({
-		x: x,
-		y: y + 1
-	});
-	return n;
-}
-function findCluster(x, y, colorId, visited) {
-	if (!isInsideGrid(x, y)) return [];
-	if (visited[y * GRID_COLS + x]) return [];
-	var block = grid[y][x];
-	if (!block || block.colorId !== colorId) return [];
-	visited[y * GRID_COLS + x] = true;
-	var cluster = [{
-		x: x,
-		y: y
-	}];
-	var neighbors = getNeighbors(x, y);
-	for (var i = 0; i < neighbors.length; i++) {
-		var nx = neighbors[i].x,
-			ny = neighbors[i].y;
-		cluster = cluster.concat(findCluster(nx, ny, colorId, visited));
-	}
-	return cluster;
-}
-function clearBlock(x, y) {
-	if (grid[y][x]) {
-		grid[y][x].destroy();
-		grid[y][x] = null;
-	}
-}
-function updateScoreText() {
-	if (scoreText) scoreText.setText(LK.getScore());
-}
-// --- Draw Board Background ---
-for (var y = 0; y < GRID_ROWS; y++) {
-	for (var x = 0; x < GRID_COLS; x++) {
-		var bg = LK.getAsset('block_gray', {
-			anchorX: 0.5,
-			anchorY: 0.5
-		});
-		bg.width = CELL_SIZE;
-		bg.height = CELL_SIZE;
-		bg.x = GRID_OFFSET_X + x * CELL_SIZE + CELL_SIZE / 2;
-		bg.y = GRID_OFFSET_Y + y * CELL_SIZE + CELL_SIZE / 2;
-		game.addChild(bg);
-	}
-}
-// --- Score Display ---
-scoreText = new Text2('0', {
-	size: 120,
+// 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
 });
-scoreText.anchor.set(0.5, 0);
-LK.gui.top.addChild(scoreText);
-updateScoreText();
-// --- Spawn New Block ---
-function spawnBlock() {
+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();
-		currentBlock = null;
 	}
-	var colorId = getRandomColor();
-	currentBlock = new Block();
-	currentBlock.setColor(colorId);
+	var randomColor = colors[Math.floor(Math.random() * colors.length)];
+	currentBlock = new Block(randomColor);
 	currentBlock.x = 2048 / 2;
-	currentBlock.y = 300;
-	currentBlock.asset.width = CELL_SIZE;
-	currentBlock.asset.height = CELL_SIZE;
+	currentBlock.y = 150;
 	game.addChild(currentBlock);
-	dragging = false;
-	dragSprite = null;
-	dragGridX = null;
-	dragGridY = null;
+	// Check if game is over
+	if (gameGrid.isFull()) {
+		LK.showGameOver();
+	}
 }
-spawnBlock();
-// --- Drag and Drop Handlers ---
+// Game input handling
 game.down = function (x, y, obj) {
-	if (!currentBlock) return;
-	// Only start drag if touch is on the current block
-	var dx = x - currentBlock.x;
-	var dy = y - currentBlock.y;
-	if (Math.abs(dx) < CELL_SIZE / 2 && Math.abs(dy) < CELL_SIZE / 2) {
-		dragging = true;
-		dragSprite = currentBlock;
+	if (isProcessingMerges) return;
+	if (currentBlock && currentBlock.intersects({
+		x: x,
+		y: y,
+		width: 1,
+		height: 1
+	})) {
+		draggedBlock = currentBlock;
 	}
 };
 game.move = function (x, y, obj) {
-	if (!dragging || !dragSprite) return;
-	// Snap to nearest grid cell
-	var gx = Math.floor((x - GRID_OFFSET_X) / CELL_SIZE);
-	var gy = Math.floor((y - GRID_OFFSET_Y) / CELL_SIZE);
-	if (isInsideGrid(gx, gy)) {
-		dragSprite.x = GRID_OFFSET_X + gx * CELL_SIZE + CELL_SIZE / 2;
-		dragSprite.y = GRID_OFFSET_Y + gy * CELL_SIZE + CELL_SIZE / 2;
-		dragGridX = gx;
-		dragGridY = gy;
-	} else {
-		// Follow finger
-		dragSprite.x = x;
-		dragSprite.y = y;
-		dragGridX = null;
-		dragGridY = null;
+	if (draggedBlock && !isProcessingMerges) {
+		draggedBlock.x = x;
+		draggedBlock.y = y;
 	}
 };
 game.up = function (x, y, obj) {
-	if (!dragging || !dragSprite) return;
-	if (dragGridX !== null && dragGridY !== null && !grid[dragGridY][dragGridX]) {
-		// Place block
-		dragSprite.setGridPos(dragGridX, dragGridY);
-		grid[dragGridY][dragGridX] = dragSprite;
-		// Check for merges
-		handleMerge(dragGridX, dragGridY);
-		// Check for game over
-		if (isBoardFull()) {
-			LK.showGameOver();
-			return;
+	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;
 		}
-		spawnBlock();
-	} else {
-		// Return to top
-		dragSprite.x = 2048 / 2;
-		dragSprite.y = 300;
 	}
-	dragging = false;
-	dragSprite = null;
-	dragGridX = null;
-	dragGridY = null;
+	draggedBlock = null;
 };
-// --- Merge Logic ---
-function handleMerge(gx, gy) {
-	var block = grid[gy][gx];
-	if (!block) return;
-	var colorId = block.colorId;
-	var visited = [];
-	var cluster = findCluster(gx, gy, colorId, visited);
-	if (cluster.length >= 3) {
-		// Merge!
-		var colorData = getColorData(colorId);
-		var nextColor = colorData.next;
-		var points = colorData.points * cluster.length;
-		// Remove all blocks in cluster
-		for (var i = 0; i < cluster.length; i++) {
-			var cx = cluster[i].x,
-				cy = cluster[i].y;
-			if (cx !== gx || cy !== gy) clearBlock(cx, cy);
+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();
 		}
-		// Upgrade main block
-		if (nextColor) {
-			block.setColor(nextColor);
-		}
-		LK.setScore(LK.getScore() + points);
-		updateScoreText();
-		// Chain reaction
-		handleMerge(gx, gy);
 	}
+	checkMerges();
 }
-// --- Board Full Check ---
-function isBoardFull() {
-	for (var y = 0; y < GRID_ROWS; y++) {
-		for (var x = 0; x < GRID_COLS; x++) {
-			if (!grid[y][x]) return false;
-		}
-	}
-	return true;
-}
-// --- Game Update (not used, but required for LK) ---
-game.update = function () {};
\ No newline at end of file
+// Update score display
+scoreTxt.setText('Score: ' + LK.getScore());
+// Create initial block
+createNewBlock();
\ No newline at end of file