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

/**** 
* Classes
****/ 
var BlockPiece = Container.expand(function () {
	var self = Container.call(this);
	var graphics = self.attachAsset('blockPiece', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.gridX = 0;
	self.gridY = 0;
	self.color = 0xff6b6b;
	self.setColor = function (color) {
		self.color = color;
		graphics.tint = color;
	};
	self.setExplodingAsset = function (assetId) {
		self.removeChild(graphics);
		graphics = self.attachAsset(assetId, {
			anchorX: 0.5,
			anchorY: 0.5
		});
	};
	return self;
});
var GamePiece = Container.expand(function () {
	var self = Container.call(this);
	self.blocks = [];
	self.shape = [];
	self.isDragging = false;
	self.canPlace = false;
	self.createShape = function (shapeData) {
		self.shape = shapeData;
		for (var i = 0; i < shapeData.length; i++) {
			for (var j = 0; j < shapeData[i].length; j++) {
				if (shapeData[i][j] === 1) {
					var block = new BlockPiece();
					block.x = j * 160;
					block.y = i * 160;
					block.setColor(pieceColors[Math.floor(Math.random() * pieceColors.length)]);
					self.blocks.push(block);
					self.addChild(block);
				}
			}
		}
	};
	self.down = function (x, y, obj) {
		if (!self.isDragging) {
			self.isDragging = true;
			draggedPiece = self;
			self.originalX = self.x;
			self.originalY = self.y;
			self.alpha = 0.7;
		}
	};
	return self;
});
var Particle = Container.expand(function () {
	var self = Container.call(this);
	var graphics = self.attachAsset('particle', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.velocityX = 0;
	self.velocityY = 0;
	self.lifetime = 1000;
	self.maxLifetime = 1000;
	self.update = function () {
		self.x += self.velocityX;
		self.y += self.velocityY;
		self.velocityY += 0.5; // gravity
		self.lifetime -= 16.67; // 60fps
		var alpha = self.lifetime / self.maxLifetime;
		graphics.alpha = alpha;
		if (self.lifetime <= 0) {
			self.destroy();
		}
	};
	return self;
});

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

/**** 
* Game Code
****/ 
var GRID_SIZE = 8;
var CELL_SIZE = 160;
var GRID_OFFSET_X = 544;
var GRID_OFFSET_Y = 400;
var gameState = 'menu'; // 'menu', 'playing', or 'paused'
var highScore = storage.highScore || 0;
var playButton = null;
var playButtonText = null;
var menuTitle = null;
var highScoreText = null;
var pauseOverlay = null;
var pauseTitle = null;
var quitButton = null;
var quitButtonText = null;
var resumeButton = null;
var resumeButtonText = null;
var grid = [];
var gameGrid = [];
var pieceShapes = [[[1]],
// Single block
[[1, 1]],
// Line 2
[[1, 1, 1]],
// Line 3
[[1], [1]],
// Vertical 2
[[1], [1], [1]],
// Vertical 3
[[1, 1], [1, 1]],
// Square 2x2
[[1, 1, 1], [1, 0, 0]],
// L shape
[[1, 1, 1], [0, 0, 1]],
// Reverse L
[[1, 1, 0], [0, 1, 1]] // Z shape
];
var pieceColors = [0xff6b6b, 0x4ecdc4, 0x45b7d1, 0xf7dc6f, 0xbb8fce, 0x58d68d, 0xf39c12];
var currentPieces = [];
var draggedPiece = null;
var previewBlocks = [];
var particles = [];
var comboCounter = 0;
var lastClearTime = 0;
var comboMultiplier = 1;
var lastPlaceTime = 0;
var consecutivePlacements = 0;
var recentlyUsedShapes = []; // Track recently used shapes to avoid repetition
// Initialize grid
for (var i = 0; i < GRID_SIZE; i++) {
	grid[i] = [];
	gameGrid[i] = [];
	for (var j = 0; j < GRID_SIZE; j++) {
		var cell = LK.getAsset('gridCell', {
			anchorX: 0.5,
			anchorY: 0.5,
			x: GRID_OFFSET_X + j * CELL_SIZE + CELL_SIZE / 2,
			y: GRID_OFFSET_Y + i * CELL_SIZE + CELL_SIZE / 2
		});
		grid[i][j] = cell;
		gameGrid[i][j] = null;
		game.addChild(cell);
	}
}
// Initialize UI
var scoreTxt = new Text2('0', {
	size: 80,
	fill: 0xFFFFFF
});
scoreTxt.anchor.set(0.5, 0);
LK.gui.top.addChild(scoreTxt);
var comboTxt = new Text2('', {
	size: 60,
	fill: 0xFFFF00
});
comboTxt.anchor.set(1, 0);
LK.gui.topRight.addChild(comboTxt);
// Center screen combo text
var centerComboTxt = new Text2('', {
	size: 120,
	fill: 0xFFFF00
});
centerComboTxt.anchor.set(0.5, 0.5);
centerComboTxt.x = 1024;
centerComboTxt.y = 1366;
centerComboTxt.alpha = 0;
game.addChild(centerComboTxt);
// Piece panel
var piecePanel = LK.getAsset('piecePanel', {
	anchorX: 0.5,
	anchorY: 1,
	x: 1024,
	y: 2732
});
game.addChild(piecePanel);
function createPauseMenu() {
	// Semi-transparent overlay
	pauseOverlay = LK.getAsset('gridBackground', {
		anchorX: 0.5,
		anchorY: 0.5,
		x: 1024,
		y: 1366,
		scaleX: 2,
		scaleY: 2.5,
		alpha: 0.8
	});
	game.addChild(pauseOverlay);
	// Pause title
	pauseTitle = new Text2('PAUSED', {
		size: 100,
		fill: 0xFFFFFF
	});
	pauseTitle.anchor.set(0.5, 0.5);
	pauseTitle.x = 1024;
	pauseTitle.y = 1200;
	game.addChild(pauseTitle);
	// Resume Button
	resumeButton = LK.getAsset('piecePanel', {
		anchorX: 0.5,
		anchorY: 0.5,
		x: 1024,
		y: 1400,
		scaleX: 0.4,
		scaleY: 0.25
	});
	game.addChild(resumeButton);
	resumeButtonText = new Text2('RESUME', {
		size: 60,
		fill: 0xFFFFFF
	});
	resumeButtonText.anchor.set(0.5, 0.5);
	resumeButtonText.x = 1024;
	resumeButtonText.y = 1400;
	game.addChild(resumeButtonText);
	// Quit Button
	quitButton = LK.getAsset('piecePanel', {
		anchorX: 0.5,
		anchorY: 0.5,
		x: 1024,
		y: 1600,
		scaleX: 0.4,
		scaleY: 0.25
	});
	game.addChild(quitButton);
	quitButtonText = new Text2('QUIT TO MENU', {
		size: 50,
		fill: 0xFFFFFF
	});
	quitButtonText.anchor.set(0.5, 0.5);
	quitButtonText.x = 1024;
	quitButtonText.y = 1600;
	game.addChild(quitButtonText);
	// Button handlers
	resumeButton.down = function () {
		resumeGame();
	};
	quitButton.down = function () {
		quitToMenu();
	};
}
function createMainMenu() {
	// Title
	menuTitle = new Text2('BLOCK PUZZLE', {
		size: 120,
		fill: 0xFFFFFF
	});
	menuTitle.anchor.set(0.5, 0.5);
	menuTitle.x = 1024;
	menuTitle.y = 800;
	game.addChild(menuTitle);
	// High Score
	highScoreText = new Text2('High Score: ' + highScore, {
		size: 60,
		fill: 0xFFFF00
	});
	highScoreText.anchor.set(0.5, 0.5);
	highScoreText.x = 1024;
	highScoreText.y = 1000;
	game.addChild(highScoreText);
	// Play Button
	playButton = LK.getAsset('piecePanel', {
		anchorX: 0.5,
		anchorY: 0.5,
		x: 1024,
		y: 1400,
		scaleX: 0.3,
		scaleY: 0.3
	});
	game.addChild(playButton);
	playButtonText = new Text2('PLAY', {
		size: 80,
		fill: 0xFFFFFF
	});
	playButtonText.anchor.set(0.5, 0.5);
	playButtonText.x = 1024;
	playButtonText.y = 1400;
	game.addChild(playButtonText);
	playButton.down = function () {
		startGame();
	};
}
function startGame() {
	gameState = 'playing';
	// Hide menu elements
	if (menuTitle) menuTitle.destroy();
	if (highScoreText) highScoreText.destroy();
	if (playButton) playButton.destroy();
	if (playButtonText) playButtonText.destroy();
	// Show game UI
	scoreTxt.alpha = 1;
	comboTxt.alpha = 1;
	// Show grid and piece panel
	for (var i = 0; i < GRID_SIZE; i++) {
		for (var j = 0; j < GRID_SIZE; j++) {
			grid[i][j].alpha = 1;
		}
	}
	piecePanel.alpha = 1;
	// Reset game state
	LK.setScore(0);
	scoreTxt.setText('0');
	comboCounter = 0;
	comboTxt.setText('COMBO x1');
	// Clear grid
	for (var i = 0; i < GRID_SIZE; i++) {
		for (var j = 0; j < GRID_SIZE; j++) {
			if (gameGrid[i][j]) {
				gameGrid[i][j].destroy();
				gameGrid[i][j] = null;
			}
		}
	}
	createNewPieces();
}
function resumeGame() {
	gameState = 'playing';
	// Hide pause menu elements
	if (pauseOverlay) pauseOverlay.destroy();
	if (pauseTitle) pauseTitle.destroy();
	if (resumeButton) resumeButton.destroy();
	if (resumeButtonText) resumeButtonText.destroy();
	if (quitButton) quitButton.destroy();
	if (quitButtonText) quitButtonText.destroy();
}
function quitToMenu() {
	gameState = 'menu';
	// Hide pause menu elements
	if (pauseOverlay) pauseOverlay.destroy();
	if (pauseTitle) pauseTitle.destroy();
	if (resumeButton) resumeButton.destroy();
	if (resumeButtonText) resumeButtonText.destroy();
	if (quitButton) quitButton.destroy();
	if (quitButtonText) quitButtonText.destroy();
	// Update high score if needed
	var currentScore = LK.getScore();
	if (currentScore > highScore) {
		highScore = currentScore;
		storage.highScore = highScore;
	}
	// Clear game elements
	for (var i = 0; i < currentPieces.length; i++) {
		currentPieces[i].destroy();
	}
	currentPieces = [];
	// Clear grid
	for (var i = 0; i < GRID_SIZE; i++) {
		for (var j = 0; j < GRID_SIZE; j++) {
			if (gameGrid[i][j]) {
				gameGrid[i][j].destroy();
				gameGrid[i][j] = null;
			}
		}
	}
	// Hide game UI
	scoreTxt.alpha = 0;
	comboTxt.alpha = 0;
	centerComboTxt.alpha = 0;
	// Hide grid and piece panel
	for (var i = 0; i < GRID_SIZE; i++) {
		for (var j = 0; j < GRID_SIZE; j++) {
			grid[i][j].alpha = 0;
		}
	}
	piecePanel.alpha = 0;
	createMainMenu();
}
function createNewPieces() {
	// Clear existing pieces
	for (var i = 0; i < currentPieces.length; i++) {
		currentPieces[i].destroy();
	}
	currentPieces = [];
	// Create 3 new pieces with reduced repetition
	for (var i = 0; i < 3; i++) {
		var piece = new GamePiece();
		var shapeIndex;
		var attempts = 0;
		// Try to avoid recently used shapes
		do {
			shapeIndex = Math.floor(Math.random() * pieceShapes.length);
			attempts++;
		} while (recentlyUsedShapes.indexOf(shapeIndex) !== -1 && attempts < 10);
		// Add to recently used shapes and keep only last 4
		recentlyUsedShapes.push(shapeIndex);
		if (recentlyUsedShapes.length > 4) {
			recentlyUsedShapes.shift();
		}
		piece.createShape(pieceShapes[shapeIndex]);
		piece.x = 350 + i * 500;
		piece.y = 2550;
		currentPieces.push(piece);
		game.addChild(piece);
	}
}
function getGridPosition(x, y) {
	var gridX = Math.floor((x - GRID_OFFSET_X) / CELL_SIZE);
	var gridY = Math.floor((y - GRID_OFFSET_Y) / CELL_SIZE);
	return {
		x: gridX,
		y: gridY
	};
}
function canPlacePiece(piece, gridX, gridY) {
	for (var i = 0; i < piece.shape.length; i++) {
		for (var j = 0; j < piece.shape[i].length; j++) {
			if (piece.shape[i][j] === 1) {
				var checkX = gridX + j;
				var checkY = gridY + i;
				if (checkX < 0 || checkX >= GRID_SIZE || checkY < 0 || checkY >= GRID_SIZE) {
					return false;
				}
				if (gameGrid[checkY][checkX] !== null) {
					return false;
				}
			}
		}
	}
	return true;
}
function placePiece(piece, gridX, gridY) {
	for (var i = 0; i < piece.shape.length; i++) {
		for (var j = 0; j < piece.shape[i].length; j++) {
			if (piece.shape[i][j] === 1) {
				var placeX = gridX + j;
				var placeY = gridY + i;
				var block = new BlockPiece();
				block.x = GRID_OFFSET_X + placeX * CELL_SIZE + CELL_SIZE / 2;
				block.y = GRID_OFFSET_Y + placeY * CELL_SIZE + CELL_SIZE / 2;
				block.setColor(piece.blocks[0].color);
				block.gridX = placeX;
				block.gridY = placeY;
				gameGrid[placeY][placeX] = block;
				game.addChild(block);
			}
		}
	}
	// Track consecutive placements for combo continuation
	var currentTime = Date.now();
	if (currentTime - lastPlaceTime < 3000) {
		consecutivePlacements++;
	} else {
		consecutivePlacements = 1;
	}
	lastPlaceTime = currentTime;
	LK.getSound('blockPlace').play();
}
function clearPreview() {
	for (var i = 0; i < previewBlocks.length; i++) {
		previewBlocks[i].destroy();
	}
	previewBlocks = [];
}
function showPreview(piece, gridX, gridY) {
	clearPreview();
	if (canPlacePiece(piece, gridX, gridY)) {
		for (var i = 0; i < piece.shape.length; i++) {
			for (var j = 0; j < piece.shape[i].length; j++) {
				if (piece.shape[i][j] === 1) {
					var previewX = gridX + j;
					var previewY = gridY + i;
					var preview = LK.getAsset('previewBlock', {
						anchorX: 0.5,
						anchorY: 0.5,
						x: GRID_OFFSET_X + previewX * CELL_SIZE + CELL_SIZE / 2,
						y: GRID_OFFSET_Y + previewY * CELL_SIZE + CELL_SIZE / 2,
						alpha: 0.5
					});
					previewBlocks.push(preview);
					game.addChild(preview);
				}
			}
		}
	}
}
function checkLines() {
	var clearedBlocks = [];
	// Check for complete rows
	for (var i = 0; i < GRID_SIZE; i++) {
		var rowComplete = true;
		for (var j = 0; j < GRID_SIZE; j++) {
			if (gameGrid[i][j] === null) {
				rowComplete = false;
				break;
			}
		}
		if (rowComplete) {
			for (var j = 0; j < GRID_SIZE; j++) {
				clearedBlocks.push({
					x: j,
					y: i
				});
			}
		}
	}
	// Check for complete columns
	for (var j = 0; j < GRID_SIZE; j++) {
		var colComplete = true;
		for (var i = 0; i < GRID_SIZE; i++) {
			if (gameGrid[i][j] === null) {
				colComplete = false;
				break;
			}
		}
		if (colComplete) {
			for (var i = 0; i < GRID_SIZE; i++) {
				clearedBlocks.push({
					x: j,
					y: i
				});
			}
		}
	}
	if (clearedBlocks.length > 0) {
		clearBlocks(clearedBlocks);
		return true;
	}
	return false;
}
function clearBlocks(blockPositions) {
	var currentTime = Date.now();
	// Check if this clear is within 3 blocks of the last clear
	var timeSinceLastClear = currentTime - lastClearTime;
	if (timeSinceLastClear < 5000) {
		// 5 seconds window for combo - continue from where we left off
		comboCounter++;
	} else {
		comboCounter = 1;
	}
	lastClearTime = currentTime;
	// Calculate multiplier based on combo
	comboMultiplier = comboCounter;
	var uniqueBlocks = [];
	var seen = {};
	for (var i = 0; i < blockPositions.length; i++) {
		var pos = blockPositions[i];
		var key = pos.x + "," + pos.y;
		if (!seen[key] && gameGrid[pos.y][pos.x] !== null) {
			seen[key] = true;
			uniqueBlocks.push(pos);
		}
	}
	// Change block appearance before exploding
	var explodingAssets = ['explodingBlock1', 'explodingBlock2', 'explodingBlock3', 'explodingBlock4', 'explodingBlock5', 'explodingBlock6'];
	var chosenAsset = explodingAssets[Math.floor(Math.random() * explodingAssets.length)];
	for (var i = 0; i < uniqueBlocks.length; i++) {
		var pos = uniqueBlocks[i];
		var block = gameGrid[pos.y][pos.x];
		if (block) {
			block.setExplodingAsset(chosenAsset);
		}
	}
	// Delay explosion effects slightly to show the new appearance
	LK.setTimeout(function () {
		for (var i = 0; i < uniqueBlocks.length; i++) {
			var pos = uniqueBlocks[i];
			var block = gameGrid[pos.y][pos.x];
			if (block) {
				createExplosion(block.x, block.y, block.color);
				block.destroy();
				gameGrid[pos.y][pos.x] = null;
			}
		}
	}, 200);
	// Screen effects
	var flashColor = comboCounter > 3 ? 0xff0000 : 0xffffff;
	var flashDuration = Math.min(comboCounter * 100 + 200, 800);
	LK.effects.flashScreen(flashColor, flashDuration);
	// Update score with combo multiplier
	var basePoints = uniqueBlocks.length * 10;
	var finalPoints = basePoints * comboMultiplier;
	LK.setScore(LK.getScore() + Math.floor(finalPoints));
	scoreTxt.setText(LK.getScore());
	// Update combo display
	if (comboCounter > 1) {
		comboTxt.setText("COMBO x" + comboCounter);
		// Show center screen combo animation
		showCenterCombo(comboCounter);
		// Animate combo text
		tween(comboTxt, {
			scaleX: 1.5,
			scaleY: 1.5
		}, {
			duration: 200,
			easing: tween.easeOut
		});
		tween(comboTxt, {
			scaleX: 1,
			scaleY: 1
		}, {
			duration: 300,
			easing: tween.easeInOut
		});
		// Add color flash to combo text
		tween(comboTxt, {
			tint: 0xFFFF00
		}, {
			duration: 100,
			onFinish: function onFinish() {
				tween(comboTxt, {
					tint: 0xFFFFFF
				}, {
					duration: 200
				});
			}
		});
	} else {
		comboTxt.setText("COMBO x1");
		// Show center screen combo for first clear too
		showCenterCombo(comboCounter);
		// Reset combo text color
		comboTxt.tint = 0xFFFFFF;
	}
	// Play sound
	if (comboCounter > 2) {
		LK.getSound('comboClear').play();
	} else {
		LK.getSound('lineClear').play();
	}
}
function showCenterCombo(combo) {
	// Stop any existing combo animation
	tween.stop(centerComboTxt);
	// Set combo text
	centerComboTxt.setText("COMBO x" + combo + "!");
	centerComboTxt.scaleX = 0.5;
	centerComboTxt.scaleY = 0.5;
	centerComboTxt.alpha = 0;
	// Animate in
	tween(centerComboTxt, {
		scaleX: 1.2,
		scaleY: 1.2,
		alpha: 1
	}, {
		duration: 300,
		easing: tween.easeOut,
		onFinish: function onFinish() {
			// Hold for a moment then animate out
			tween(centerComboTxt, {
				scaleX: 0.8,
				scaleY: 0.8,
				alpha: 0
			}, {
				duration: 800,
				easing: tween.easeIn
			});
		}
	});
}
function createExplosion(x, y, color) {
	var particleCount = Math.min(comboCounter * 2 + 5, 20);
	for (var i = 0; i < particleCount; i++) {
		var particle = new Particle();
		particle.x = x;
		particle.y = y;
		particle.velocityX = (Math.random() - 0.5) * 10;
		particle.velocityY = (Math.random() - 0.5) * 10 - 5;
		particle.lifetime = 500 + Math.random() * 500;
		particle.maxLifetime = particle.lifetime;
		var particleGraphics = particle.children[0];
		particleGraphics.tint = color;
		particles.push(particle);
		game.addChild(particle);
	}
}
function checkGameOver() {
	for (var i = 0; i < currentPieces.length; i++) {
		var piece = currentPieces[i];
		var canPlace = false;
		for (var row = 0; row < GRID_SIZE; row++) {
			for (var col = 0; col < GRID_SIZE; col++) {
				if (canPlacePiece(piece, col, row)) {
					canPlace = true;
					break;
				}
			}
			if (canPlace) break;
		}
		if (canPlace) return false;
	}
	return true;
}
game.move = function (x, y, obj) {
	if (gameState === 'playing' && draggedPiece) {
		draggedPiece.x = x;
		draggedPiece.y = y;
		var gridPos = getGridPosition(x, y);
		showPreview(draggedPiece, gridPos.x, gridPos.y);
	}
};
game.down = function (x, y, obj) {
	// Check if we're in playing state and not dragging anything
	if (gameState === 'playing' && !draggedPiece) {
		// Only show pause menu if tapping in top-left corner (100x100px area)
		if (x <= 100 && y <= 100) {
			gameState = 'paused';
			createPauseMenu();
		}
	}
};
game.up = function (x, y, obj) {
	if (gameState === 'playing' && draggedPiece) {
		var gridPos = getGridPosition(x, y);
		if (canPlacePiece(draggedPiece, gridPos.x, gridPos.y)) {
			placePiece(draggedPiece, gridPos.x, gridPos.y);
			// Remove piece from current pieces
			var index = currentPieces.indexOf(draggedPiece);
			if (index > -1) {
				currentPieces.splice(index, 1);
			}
			draggedPiece.destroy();
			// Check for clears
			checkLines();
			// Create new pieces if all are used
			if (currentPieces.length === 0) {
				createNewPieces();
			}
		} else {
			// Return piece to original position
			tween(draggedPiece, {
				x: draggedPiece.originalX,
				y: draggedPiece.originalY,
				alpha: 1
			}, {
				duration: 300
			});
			draggedPiece.isDragging = false;
		}
		clearPreview();
		draggedPiece = null;
	}
};
game.update = function () {
	// Clean up particles
	for (var i = particles.length - 1; i >= 0; i--) {
		var particle = particles[i];
		if (particle.lifetime <= 0) {
			particles.splice(i, 1);
		}
	}
	// Reset combo if enough time passed (5 seconds) and no recent placements
	var timeSinceLastClear = Date.now() - lastClearTime;
	var timeSinceLastPlace = Date.now() - lastPlaceTime;
	if (timeSinceLastClear > 5000 && timeSinceLastPlace > 3000 && comboCounter > 0) {
		comboCounter = 0;
		consecutivePlacements = 0;
		comboTxt.setText("");
		// Hide center combo text
		tween.stop(centerComboTxt);
		centerComboTxt.alpha = 0;
	}
	// Check game over
	if (gameState === 'playing' && currentPieces.length > 0 && checkGameOver()) {
		// Update high score if needed
		var currentScore = LK.getScore();
		if (currentScore > highScore) {
			highScore = currentScore;
			storage.highScore = highScore;
		}
		// Clear game elements
		for (var i = 0; i < currentPieces.length; i++) {
			currentPieces[i].destroy();
		}
		currentPieces = [];
		// Hide game UI
		scoreTxt.alpha = 0;
		comboTxt.alpha = 0;
		centerComboTxt.alpha = 0;
		// Hide grid and piece panel
		for (var i = 0; i < GRID_SIZE; i++) {
			for (var j = 0; j < GRID_SIZE; j++) {
				grid[i][j].alpha = 0;
			}
		}
		piecePanel.alpha = 0;
		gameState = 'menu';
		createMainMenu();
	}
};
// Initialize game
scoreTxt.alpha = 0;
comboTxt.alpha = 0;
// Hide grid initially
for (var i = 0; i < GRID_SIZE; i++) {
	for (var j = 0; j < GRID_SIZE; j++) {
		grid[i][j].alpha = 0;
	}
}
piecePanel.alpha = 0;
createMainMenu();
LK.playMusic('bgmusic');
;

===================================================================
--- original.js
+++ change.js
@@ -705,12 +705,10 @@
 };
 game.down = function (x, y, obj) {
 	// Check if we're in playing state and not dragging anything
 	if (gameState === 'playing' && !draggedPiece) {
-		// Check if tap is outside game area (not on pieces or grid)
-		var gridPos = getGridPosition(x, y);
-		if (gridPos.x < 0 || gridPos.x >= GRID_SIZE || gridPos.y < 0 || gridPos.y >= GRID_SIZE) {
-			// Tapped outside grid, show pause menu
+		// Only show pause menu if tapping in top-left corner (100x100px area)
+		if (x <= 100 && y <= 100) {
 			gameState = 'paused';
 			createPauseMenu();
 		}
 	}