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

/**** 
* Classes
****/ 
// --- Game Over / Reset handled by LK engine ---
// --- Block Class ---
var Block = Container.expand(function () {
	var self = Container.call(this);
	// Default color index (0=red, 1=orange, 2=yellow, 3=green, 4=blue, 5=purple, 6=pink, 7=white, 8=rainbow)
	self.colorIndex = 0;
	self.isLocked = false;
	self.isOnGrid = false;
	self.gridX = -1;
	self.gridY = -1;
	// Attach block asset (default, will be set by setColor)
	self.blockAsset = self.attachAsset('Hd', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.scaleX = 1;
	self.scaleY = 1;
	// Set color and locked state
	self.setColor = function (colorIdx) {
		self.colorIndex = colorIdx;
		self.isLocked = false; // No more locked blocks
		// Remove old asset if exists
		if (self.blockAsset) {
			self.removeChild(self.blockAsset);
		}
		self.blockAsset = self.attachAsset('Hd', {
			anchorX: 0.5,
			anchorY: 0.5
		});
		self.scaleX = 1;
		self.scaleY = 1;
		// Assign each block a unique light color using the Hd asset for all
		var tints = [0xFFF600,
		// Yellow
		0xFF6666,
		// Light Red
		0x66B3FF,
		// Light Blue
		0xFFB3E6,
		// Light Pink
		// 0x7CFF6B, // Light Green (removed)
		// 0x7FDBFF, // Light Sky Blue (removed)
		// 0x30FFF6, // Turquoise (removed)
		0xFFFFFF,
		// White
		0xBBBBBB,
		// Light Gray (for black, but light)
		0xFFD580,
		// Light Orange
		0xA3A3FF,
		// Changed: Soft Periwinkle (was Light Purple)
		0xE6FFB3,
		// Light Lime
		0xB3C6FF,
		// Light Navy
		0xFFB3FF,
		// Light Magenta
		0xB3FFF6 // Light Teal
		];
		// Ensure all tints are unique and light
		if (colorIdx >= 0 && colorIdx < tints.length) {
			self.blockAsset.tint = tints[colorIdx];
			// Add a lightful flash effect when color is set
			LK.effects.flashObject(self.blockAsset, 0xffffff, 220);
		} else if (colorIdx === tints.length) {
			// Rainbow block: visually white, but can be replaced with a special color if desired
			self.blockAsset.tint = 0xffffff;
			LK.effects.flashObject(self.blockAsset, 0xffffff, 220);
		} else {
			self.blockAsset.tint = 0xffffff;
			LK.effects.flashObject(self.blockAsset, 0xffffff, 220);
		}
	};
	// Animate merge (scale up and back)
	self.animateMerge = function (_onFinish) {
		tween(self, {
			scaleX: 1.25,
			scaleY: 1.25
		}, {
			duration: 80,
			easing: tween.easeOut,
			onFinish: function onFinish() {
				tween(self, {
					scaleX: 1,
					scaleY: 1
				}, {
					duration: 100,
					easing: tween.easeIn,
					onFinish: function onFinish() {
						if (_onFinish) _onFinish();
					}
				});
			}
		});
	};
	return self;
});

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

/**** 
* Game Code
****/ 
// Cheerful honey yellow
// Cheerful pink
// Cheerful yellow
// Pure white
// Cheerful red
// Bright yellow for rainbow
// Cheerful purple
// Cheerful green
// Cheerful blue
// More defined, fun, and clear block shapes for each color
// visually white, but will be rainbow in logic
// Sound for merge
// Merged block (final color)
// We'll use 4 colors: red, blue, yellow, purple (no green)
// Define block shapes for each color and merged color
// --- Game Constants ---
// locked block
// Removed block_gray asset initialization (no more grey squares)
// Face assets in different colors
// Flower and honey jar assets
var GRID_COLS = 6;
var GRID_ROWS = 7;
var CELL_SIZE = 260; // px (was 200, now bigger for larger squares)
var GRID_OFFSET_X = Math.floor((2048 - GRID_COLS * CELL_SIZE) / 2);
var GRID_OFFSET_Y = 350;
var COLORS = [0, 1, 2, 4]; // 0=yellow, 1=red, 2=blue, 4=purple (removed green)
var COLOR_NAMES = ['yellow', 'red', 'blue', 'purple'];
var MAX_COLOR_INDEX = 4; // 0-4 normal, 5=rainbow (special, can't merge further)
var RAINBOW_COLOR_INDEX = 5; // special rainbow block (if needed)
var BLOCK_DROP_Y = 2200; // y position for blocks that fall off
// --- Game State ---
var grid = []; // 2D array [col][row] of Block or null
for (var c = 0; c < GRID_COLS; c++) {
	grid[c] = [];
	for (var r = 0; r < GRID_ROWS; r++) {
		grid[c][r] = null;
	}
}
var draggingBlock = null;
var dragOffsetX = 0;
var dragOffsetY = 0;
var nextBlocks = []; // Array of next blocks to place
var score = 0;
var scoreTxt = null;
var isProcessing = false; // Prevent input during merges
// --- Undo/Föregående State ---
var prevState = null;
// Helper: Deep copy grid state (only colorIndex, isLocked, isOnGrid, gridX, gridY)
function copyGridState(srcGrid) {
	var arr = [];
	for (var c = 0; c < GRID_COLS; c++) {
		arr[c] = [];
		for (var r = 0; r < GRID_ROWS; r++) {
			var b = srcGrid[c][r];
			if (b) {
				arr[c][r] = {
					colorIndex: b.colorIndex,
					isLocked: b.isLocked,
					isOnGrid: b.isOnGrid,
					gridX: b.gridX,
					gridY: b.gridY
				};
			} else {
				arr[c][r] = null;
			}
		}
	}
	return arr;
}
// Helper: Deep copy nextBlocks state (only colorIndex)
function copyNextBlocksState(srcNextBlocks) {
	var arr = [];
	for (var i = 0; i < srcNextBlocks.length; i++) {
		arr.push({
			colorIndex: srcNextBlocks[i].colorIndex
		});
	}
	return arr;
}
// Save current state for undo
function savePrevState() {
	prevState = {
		grid: copyGridState(grid),
		nextBlocks: copyNextBlocksState(nextBlocks),
		score: score
	};
}
// Restore previous state (undo)
function restorePrevState() {
	if (!prevState) return;
	// Remove all blocks from game
	for (var c = 0; c < GRID_COLS; c++) {
		for (var r = 0; r < GRID_ROWS; r++) {
			if (grid[c][r]) {
				grid[c][r].destroy();
				grid[c][r] = null;
			}
		}
	}
	// Restore grid
	for (var c = 0; c < GRID_COLS; c++) {
		for (var r = 0; r < GRID_ROWS; r++) {
			var bdata = prevState.grid[c][r];
			if (bdata) {
				var b = new Block();
				b.setColor(bdata.colorIndex);
				b.isOnGrid = bdata.isOnGrid;
				b.gridX = bdata.gridX;
				b.gridY = bdata.gridY;
				var pos = getPosForCell(c, r);
				b.x = pos.x;
				b.y = pos.y;
				grid[c][r] = b;
				game.addChild(b);
			} else {
				grid[c][r] = null;
			}
		}
	}
	// Remove all nextBlocks from game
	for (var i = 0; i < nextBlocks.length; i++) {
		if (nextBlocks[i]) nextBlocks[i].destroy();
	}
	nextBlocks = [];
	// Restore nextBlocks
	for (var i = 0; i < prevState.nextBlocks.length; i++) {
		var nb = new Block();
		nb.setColor(prevState.nextBlocks[i].colorIndex);
		nb.x = 2048 / 2 + (nextBlocks.length - 1) * 220;
		nb.y = 220;
		nb.scaleX = nb.scaleY = 1;
		nb.isOnGrid = false;
		nb.gridX = -1;
		nb.gridY = -1;
		game.addChild(nb);
		nextBlocks.push(nb);
	}
	// Reposition nextBlocks
	for (var i = 0; i < nextBlocks.length; i++) {
		var bx = 2048 / 2 + (i - 1) * 220;
		nextBlocks[i].x = bx;
		nextBlocks[i].y = 220;
	}
	// Restore score
	score = prevState.score;
	scoreTxt.setText(score);
	prevState = null;
}
// Add a button for undo/föregående
var undoBtn = new Text2('⟲', {
	size: 110,
	fill: "#fff"
});
undoBtn.anchor.set(0.5, 0.5);
undoBtn.x = 2048 - 120;
undoBtn.y = 120;
undoBtn.interactive = true;
undoBtn.buttonMode = true;
undoBtn.down = function () {
	restorePrevState();
};
LK.gui.top.addChild(undoBtn);
// --- GUI Elements ---
scoreTxt = new Text2('0', {
	size: 120,
	fill: 0xFFFFFF
});
scoreTxt.anchor.set(0.5, 0);
LK.gui.top.addChild(scoreTxt);
// --- Draw Background Image ---
var background = LK.getAsset('Background', {
	width: 2048,
	height: 2732,
	anchorX: 0,
	anchorY: 0,
	x: 0,
	y: 0,
	alpha: 1
});
game.addChild(background);
// --- Draw Grid Background ---
for (var c = 0; c < GRID_COLS; c++) {
	for (var r = 0; r < GRID_ROWS; r++) {
		var cell = LK.getAsset('block_white', {
			anchorX: 0.5,
			anchorY: 0.5,
			x: GRID_OFFSET_X + c * CELL_SIZE + CELL_SIZE / 2,
			y: GRID_OFFSET_Y + r * CELL_SIZE + CELL_SIZE / 2,
			alpha: 0.08
		});
		game.addChild(cell);
	}
}
// --- Draw Grid Lines ---
for (var c = 0; c <= GRID_COLS; c++) {
	var x = GRID_OFFSET_X + c * CELL_SIZE;
	var y1 = GRID_OFFSET_Y;
	var y2 = GRID_OFFSET_Y + GRID_ROWS * CELL_SIZE;
	// Draw vertical line as a thick, high-contrast rectangle
	var vline = LK.getAsset('block_black', {
		width: 14,
		height: GRID_ROWS * CELL_SIZE,
		anchorX: 0.5,
		anchorY: 0,
		x: x,
		y: y1,
		alpha: 0.38
	});
	game.addChild(vline);
}
for (var r = 0; r <= GRID_ROWS; r++) {
	var y = GRID_OFFSET_Y + r * CELL_SIZE;
	var x1 = GRID_OFFSET_X;
	var x2 = GRID_OFFSET_X + GRID_COLS * CELL_SIZE;
	// Draw horizontal line as a thick, high-contrast rectangle
	var hline = LK.getAsset('block_black', {
		width: GRID_COLS * CELL_SIZE,
		height: 14,
		anchorX: 0,
		anchorY: 0.5,
		x: x1,
		y: y,
		alpha: 0.38
	});
	game.addChild(hline);
}
// --- Helper Functions ---
// Get grid cell from x,y (game coordinates)
function getGridCellFromPos(x, y) {
	var gx = Math.floor((x - GRID_OFFSET_X) / CELL_SIZE);
	var gy = Math.floor((y - GRID_OFFSET_Y) / CELL_SIZE);
	if (gx < 0 || gx >= GRID_COLS || gy < 0 || gy >= GRID_ROWS) return null;
	return {
		col: gx,
		row: gy
	};
}
// Get position (x,y) for grid cell
function getPosForCell(col, row) {
	return {
		x: GRID_OFFSET_X + col * CELL_SIZE + CELL_SIZE / 2,
		y: GRID_OFFSET_Y + row * CELL_SIZE + CELL_SIZE / 2
	};
}
// Generate a random color index (0-4)
function randomColorIndex() {
	return COLORS[Math.floor(Math.random() * COLORS.length)];
}
// Create a new block for the "next" area
function createNextBlock(idx) {
	var block = new Block();
	block.setColor(idx);
	block.x = 2048 / 2 + (nextBlocks.length - 1) * 220;
	block.y = 220;
	block.scaleX = block.scaleY = 1;
	block.isOnGrid = false;
	block.gridX = -1;
	block.gridY = -1;
	game.addChild(block);
	return block;
}
// Fill nextBlocks to always have 3 blocks
function refillNextBlocks() {
	// Limit: Only allow new blocks if there is at least one empty cell on the grid
	var emptyCells = 0;
	for (var c = 0; c < GRID_COLS; c++) {
		for (var r = 0; r < GRID_ROWS; r++) {
			if (!grid[c][r]) emptyCells++;
		}
	}
	// Only allow up to 3 next blocks, but never more than empty cells
	var maxNext = Math.min(3, emptyCells);
	// Shuffle COLORS for more variation in nextBlocks
	// Always shuffle COLORS for maximum color variation
	var arr = [];
	for (var i = 0; i < COLORS.length; i++) arr[i] = COLORS[i];
	// Fisher-Yates shuffle
	for (var i = arr.length - 1; i > 0; i--) {
		var j = Math.floor(Math.random() * (i + 1));
		var tmp = arr[i];
		arr[i] = arr[j];
		arr[j] = tmp;
	}
	refillNextBlocks._shuffledColors = arr;
	// Remove already used colors from shuffledColors to ensure all next blocks have unique colors
	var usedColors = {};
	for (var i = 0; i < nextBlocks.length; i++) {
		if (nextBlocks[i].colorIndex !== RAINBOW_COLOR_INDEX) {
			usedColors[nextBlocks[i].colorIndex] = true;
		}
	}
	var availableColors = [];
	for (var i = 0; i < refillNextBlocks._shuffledColors.length; i++) {
		var color = refillNextBlocks._shuffledColors[i];
		if (!usedColors[color]) availableColors.push(color);
	}
	var colorPickIndex = 0;
	while (nextBlocks.length < maxNext) {
		// 5% chance to spawn a rainbow block, otherwise assign a unique color for each block
		var idx;
		var rand = Math.random();
		if (rand < 0.05) {
			idx = RAINBOW_COLOR_INDEX; // rainbow
		} else {
			// Use availableColors for unique color per block
			if (colorPickIndex >= availableColors.length) {
				// If we run out, reshuffle and reset
				// (should not happen unless maxNext > COLORS.length)
				for (var i = 0; i < COLORS.length; i++) availableColors[i] = COLORS[i];
				// Fisher-Yates shuffle
				for (var i = availableColors.length - 1; i > 0; i--) {
					var j = Math.floor(Math.random() * (i + 1));
					var tmp = availableColors[i];
					availableColors[i] = availableColors[j];
					availableColors[j] = tmp;
				}
				colorPickIndex = 0;
			}
			idx = availableColors[colorPickIndex];
			colorPickIndex++;
		}
		var block = createNextBlock(idx);
		nextBlocks.push(block);
	}
	// Remove excess nextBlocks if grid is almost full
	while (nextBlocks.length > maxNext) {
		var b = nextBlocks.pop();
		if (b) b.destroy();
	}
	// Position them nicely
	for (var i = 0; i < nextBlocks.length; i++) {
		var bx = 2048 / 2 + (i - 1) * 220;
		tween(nextBlocks[i], {
			x: bx,
			y: 220
		}, {
			duration: 180,
			easing: tween.easeInOut
		});
	}
}
// Remove a block from nextBlocks and shift others
function popNextBlock(block) {
	var idx = nextBlocks.indexOf(block);
	if (idx >= 0) {
		nextBlocks.splice(idx, 1);
	}
	refillNextBlocks();
}
// Place block on grid
function placeBlockOnGrid(block, col, row) {
	block.isOnGrid = true;
	block.gridX = col;
	block.gridY = row;
	grid[col][row] = block;
	var pos = getPosForCell(col, row);
	tween(block, {
		x: pos.x,
		y: pos.y,
		scaleX: 1,
		scaleY: 1
	}, {
		duration: 120,
		easing: tween.easeOut
	});
}
// Remove block from grid
function removeBlockFromGrid(col, row) {
	var block = grid[col][row];
	if (block) {
		grid[col][row] = null;
	}
}
// Find all connected blocks of the same color (DFS)
function findConnectedBlocks(col, row, colorIndex, visited) {
	if (col < 0 || col >= GRID_COLS || row < 0 || row >= GRID_ROWS) return [];
	if (visited[col + "," + row]) return [];
	var block = grid[col][row];
	if (!block || block.colorIndex !== colorIndex) return [];
	visited[col + "," + row] = true;
	var result = [{
		col: col,
		row: row,
		block: block
	}];
	// 4 directions
	var dirs = [[1, 0], [-1, 0], [0, 1], [0, -1]];
	for (var i = 0; i < dirs.length; i++) {
		var nc = col + dirs[i][0];
		var nr = row + dirs[i][1];
		result = result.concat(findConnectedBlocks(nc, nr, colorIndex, visited));
	}
	return result;
}
// Check if any moves are possible (empty cell exists)
function hasMoves() {
	for (var c = 0; c < GRID_COLS; c++) {
		for (var r = 0; r < GRID_ROWS; r++) {
			if (!grid[c][r]) return true;
		}
	}
	return false;
}
// --- Game Logic ---
// Handle block drop onto grid
function tryPlaceBlock(block, x, y) {
	if (isProcessing) return false;
	var cell = getGridCellFromPos(x, y);
	if (!cell) return false;
	var col = cell.col,
		row = cell.row;
	if (grid[col][row]) return false; // occupied
	// No locked blocks, so no need to check
	if (grid[col][row]) return false; // cell is occupied
	if (block.colorIndex === RAINBOW_COLOR_INDEX) {
		// Rainbow block special checks
	}
	// Save state for undo before placing
	savePrevState();
	if (block.colorIndex === RAINBOW_COLOR_INDEX) {
		// Place rainbow block and trigger effect
		placeBlockOnGrid(block, col, row);
		block.isOnGrid = true;
		popNextBlock(block);
		// Pick a random color present on the grid (not locked, not white, not rainbow)
		var presentColors = {};
		for (var c2 = 0; c2 < GRID_COLS; c2++) {
			for (var r2 = 0; r2 < GRID_ROWS; r2++) {
				var b2 = grid[c2][r2];
				if (b2 && (b2.colorIndex === 0 || b2.colorIndex === 1 || b2.colorIndex === 2 || b2.colorIndex === 4)) {
					presentColors[b2.colorIndex] = true;
				}
			}
		}
		var colorList = [];
		for (var k in presentColors) {
			if (presentColors.hasOwnProperty(k)) colorList.push(parseInt(k));
		}
		if (colorList.length > 0) {
			var colorToClear = colorList[Math.floor(Math.random() * colorList.length)];
			// Animate and remove all blocks of that color
			for (var c2 = 0; c2 < GRID_COLS; c2++) {
				for (var r2 = 0; r2 < GRID_ROWS; r2++) {
					var b2 = grid[c2][r2];
					if (b2 && b2.colorIndex === colorToClear) {
						var tmpBlock = b2; // Store reference before nulling the grid position
						grid[c2][r2] = null;
						(function (bref) {
							tween(bref, {
								scaleX: 0,
								scaleY: 0,
								alpha: 0
							}, {
								duration: 180,
								easing: tween.easeIn,
								onFinish: function onFinish() {
									bref.destroy();
								}
							});
						})(tmpBlock);
					}
				}
			}
			// Add bonus score for rainbow clear
			score += 200;
			scoreTxt.setText(score);
		}
		// Play a sound for rainbow effect
		LK.getSound('merge').play();
		// After effect, check for game over
		LK.setTimeout(function () {
			if (!hasMoves()) {
				LK.showGameOver();
			}
		}, 220);
		return true;
	}
	// Place block
	placeBlockOnGrid(block, col, row);
	popNextBlock(block);
	// After placement, check for merges
	processMerges(col, row, function () {
		// After all merges and cascades, check for game over
		if (!hasMoves()) {
			LK.showGameOver();
		}
	});
	return true;
}
// Process merges and cascades starting from (col,row)
function processMerges(col, row, onFinish) {
	if (isProcessing) return;
	isProcessing = true;
	var block = grid[col][row];
	if (!block || block.isLocked) {
		isProcessing = false;
		if (onFinish) onFinish();
		return;
	}
	var colorIdx = block.colorIndex;
	if (colorIdx >= MAX_COLOR_INDEX) {
		isProcessing = false;
		if (onFinish) onFinish();
		return;
	}
	// Find all connected blocks of same color
	var connected = findConnectedBlocks(col, row, colorIdx, {});
	if (connected.length >= 3) {
		// Play happy merge sound only on actual merge
		LK.getSound('merge').play();
		// Find center position for merged block
		var sumX = 0,
			sumY = 0;
		for (var i = 0; i < connected.length; i++) {
			sumX += connected[i].col;
			sumY += connected[i].row;
		}
		var centerCol = Math.round(sumX / connected.length);
		var centerRow = Math.round(sumY / connected.length);
		// Remove all blocks in connected, but delay the destruction until after the merged block is created
		var blocksToRemove = [];
		for (var i = 0; i < connected.length; i++) {
			var b = connected[i].block;
			blocksToRemove.push(b);
			removeBlockFromGrid(b.gridX, b.gridY);
		}
		// Pick a new color for the merged block (must be different from merged color)
		var usedColors = {};
		for (var i = 0; i < connected.length; i++) {
			usedColors[connected[i].block.colorIndex] = true;
		}
		// Pick a color not in usedColors, or fallback to a random color
		var availableColors = [];
		for (var i = 0; i < COLORS.length; i++) {
			if (!usedColors[COLORS[i]]) availableColors.push(COLORS[i]);
		}
		// Always merge to a new color different from the merged color (fixes green and all others)
		var newColorIdx;
		var fallbackColors = [];
		for (var i = 0; i < COLORS.length; i++) {
			if (COLORS[i] !== colorIdx) fallbackColors.push(COLORS[i]);
		}
		if (fallbackColors.length > 0) {
			newColorIdx = fallbackColors[Math.floor(Math.random() * fallbackColors.length)];
		} else {
			newColorIdx = COLORS[Math.floor(Math.random() * COLORS.length)];
		}
		// Create merged block at center position
		var mergedBlock = new Block();
		mergedBlock.setColor(newColorIdx);
		mergedBlock.isOnGrid = true;
		mergedBlock.gridX = centerCol;
		mergedBlock.gridY = centerRow;
		var pos = getPosForCell(centerCol, centerRow);
		mergedBlock.x = pos.x;
		mergedBlock.y = pos.y;
		grid[centerCol][centerRow] = mergedBlock;
		game.addChild(mergedBlock);
		mergedBlock.animateMerge();
		// Now animate and destroy the old blocks (after the merged block is visible)
		for (var i = 0; i < blocksToRemove.length; i++) {
			(function (bref) {
				tween(bref, {
					scaleX: 0,
					scaleY: 0,
					alpha: 0
				}, {
					duration: 120,
					easing: tween.easeIn,
					onFinish: function onFinish() {
						bref.destroy();
					}
				});
			})(blocksToRemove[i]);
		}
		// Update score
		var points = 10 * connected.length * (colorIdx + 1);
		score += points;
		scoreTxt.setText(score);
		// After animation, finish processing
		LK.setTimeout(function () {
			isProcessing = false;
			// After merge, check if the new merged block itself can merge again (chain reaction)
			processMerges(centerCol, centerRow, onFinish);
		}, 180);
	} else {
		isProcessing = false;
		if (onFinish) onFinish();
	}
}
// --- Input Handling ---
// Only allow dragging from nextBlocks
game.down = function (x, y, obj) {
	if (isProcessing) return;
	for (var i = 0; i < nextBlocks.length; i++) {
		var block = nextBlocks[i];
		// Check if touch is inside block
		var dx = x - block.x;
		var dy = y - block.y;
		if (Math.abs(dx) < 90 && Math.abs(dy) < 90 && !block.isLocked && !block.isOnGrid) {
			draggingBlock = block;
			dragOffsetX = dx;
			dragOffsetY = dy;
			// Play a sound when picking up a block
			LK.getSound('merge').play();
			// Bring to front
			game.addChild(block);
			tween(block, {
				scaleX: 1.15,
				scaleY: 1.15
			}, {
				duration: 80,
				easing: tween.easeOut
			});
			break;
		}
	}
};
game.move = function (x, y, obj) {
	if (!draggingBlock) return;
	draggingBlock.x = x - dragOffsetX;
	draggingBlock.y = y - dragOffsetY;
};
game.up = function (x, y, obj) {
	if (!draggingBlock) return;
	// Try to place on grid
	var placed = tryPlaceBlock(draggingBlock, draggingBlock.x, draggingBlock.y);
	if (!placed) {
		// Snap back to next area
		var idx = nextBlocks.indexOf(draggingBlock);
		var bx = 2048 / 2 + (idx - 1) * 220;
		tween(draggingBlock, {
			x: bx,
			y: 220,
			scaleX: 1,
			scaleY: 1
		}, {
			duration: 120,
			easing: tween.easeInOut
		});
	} else {
		// Play a sound when block is placed on the grid
		LK.getSound('merge').play();
		// Block is now on grid, don't need to do anything
	}
	draggingBlock = null;
};
// --- Game Update Loop ---
game.update = function () {
	// Animate blocks falling off (if any)
	for (var c = 0; c < GRID_COLS; c++) {
		for (var r = 0; r < GRID_ROWS; r++) {
			var block = grid[c][r];
			if (block && block.y > BLOCK_DROP_Y) {
				block.destroy();
				grid[c][r] = null;
			}
		}
	}
	// Occasionally spawn a locked block in a random empty cell (every 10 turns)
	if (typeof game.turnsSinceLock === "undefined") game.turnsSinceLock = 0;
	if (typeof game.lastBlocksOnGrid === "undefined") game.lastBlocksOnGrid = 0;
	var blocksOnGrid = 0;
	for (var c = 0; c < GRID_COLS; c++) {
		for (var r = 0; r < GRID_ROWS; r++) {
			if (grid[c][r]) blocksOnGrid++;
		}
	}
	// Removed logic for spawning gray/locked blocks every 10 turns (no more grey squares)
	if (blocksOnGrid > game.lastBlocksOnGrid) {
		game.turnsSinceLock++;
		game.lastBlocksOnGrid = blocksOnGrid;
		// No locked block spawn
	}
};
// --- Game Start ---
score = 0;
scoreTxt.setText(score);
refillNextBlocks();

===================================================================
--- original.js
+++ change.js
@@ -45,14 +45,11 @@
 		0x66B3FF,
 		// Light Blue
 		0xFFB3E6,
 		// Light Pink
-		0x7CFF6B,
-		// Light Green
-		0x7FDBFF,
-		// Light Sky Blue
-		0x30FFF6,
-		// Turquoise
+		// 0x7CFF6B, // Light Green (removed)
+		// 0x7FDBFF, // Light Sky Blue (removed)
+		// 0x30FFF6, // Turquoise (removed)
 		0xFFFFFF,
 		// White
 		0xBBBBBB,
 		// Light Gray (for black, but light)
@@ -129,9 +126,9 @@
 // More defined, fun, and clear block shapes for each color
 // visually white, but will be rainbow in logic
 // Sound for merge
 // Merged block (final color)
-// We'll use 5 colors: red, green, blue, yellow, purple
+// We'll use 4 colors: red, blue, yellow, purple (no green)
 // Define block shapes for each color and merged color
 // --- Game Constants ---
 // locked block
 // Removed block_gray asset initialization (no more grey squares)
@@ -141,10 +138,10 @@
 var GRID_ROWS = 7;
 var CELL_SIZE = 260; // px (was 200, now bigger for larger squares)
 var GRID_OFFSET_X = Math.floor((2048 - GRID_COLS * CELL_SIZE) / 2);
 var GRID_OFFSET_Y = 350;
-var COLORS = [0, 1, 2, 3, 4]; // 0=yellow, 1=red, 2=blue, 3=green, 4=purple
-var COLOR_NAMES = ['yellow', 'red', 'blue', 'green', 'purple'];
+var COLORS = [0, 1, 2, 4]; // 0=yellow, 1=red, 2=blue, 4=purple (removed green)
+var COLOR_NAMES = ['yellow', 'red', 'blue', 'purple'];
 var MAX_COLOR_INDEX = 4; // 0-4 normal, 5=rainbow (special, can't merge further)
 var RAINBOW_COLOR_INDEX = 5; // special rainbow block (if needed)
 var BLOCK_DROP_Y = 2200; // y position for blocks that fall off
 // --- Game State ---
@@ -545,9 +542,9 @@
 		var presentColors = {};
 		for (var c2 = 0; c2 < GRID_COLS; c2++) {
 			for (var r2 = 0; r2 < GRID_ROWS; r2++) {
 				var b2 = grid[c2][r2];
-				if (b2 && b2.colorIndex >= 0 && b2.colorIndex <= 4) {
+				if (b2 && (b2.colorIndex === 0 || b2.colorIndex === 1 || b2.colorIndex === 2 || b2.colorIndex === 4)) {
 					presentColors[b2.colorIndex] = true;
 				}
 			}
 		}