/**** 
* Plugins
****/ 
var tween = LK.import("@upit/tween.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;
	};
	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 * 150;
					block.y = i * 150;
					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.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 = 10;
var CELL_SIZE = 150;
var GRID_OFFSET_X = 224;
var GRID_OFFSET_Y = 200;
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;
// 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);
// Piece panel
var piecePanel = LK.getAsset('piecePanel', {
	anchorX: 0.5,
	anchorY: 1,
	x: 1024,
	y: 2732
});
game.addChild(piecePanel);
function createNewPieces() {
	// Clear existing pieces
	for (var i = 0; i < currentPieces.length; i++) {
		currentPieces[i].destroy();
	}
	currentPieces = [];
	// Create 3 new pieces
	for (var i = 0; i < 3; i++) {
		var piece = new GamePiece();
		var shapeIndex = Math.floor(Math.random() * pieceShapes.length);
		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);
			}
		}
	}
	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 3x3 squares only at corners and edges
	for (var i = 0; i <= GRID_SIZE - 3; i++) {
		for (var j = 0; j <= GRID_SIZE - 3; j++) {
			// Only check positions that are at corners or edges
			var isCornerOrEdge = i === 0 || i === GRID_SIZE - 3 || j === 0 || j === GRID_SIZE - 3;
			if (!isCornerOrEdge) continue;
			var complete = true;
			for (var di = 0; di < 3; di++) {
				for (var dj = 0; dj < 3; dj++) {
					if (gameGrid[i + di][j + dj] === null) {
						complete = false;
						break;
					}
				}
				if (!complete) break;
			}
			if (complete) {
				for (var di = 0; di < 3; di++) {
					for (var dj = 0; dj < 3; dj++) {
						clearedBlocks.push({
							x: j + dj,
							y: i + di
						});
					}
				}
			}
		}
	}
	if (clearedBlocks.length > 0) {
		clearBlocks(clearedBlocks);
		return true;
	}
	return false;
}
function clearBlocks(blockPositions) {
	var currentTime = Date.now();
	if (currentTime - lastClearTime < 1000) {
		comboCounter++;
		comboMultiplier = Math.min(comboCounter * 0.5 + 1, 5);
	} else {
		comboCounter = 1;
		comboMultiplier = 1;
	}
	lastClearTime = currentTime;
	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);
		}
	}
	// Create explosion effects
	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;
		}
	}
	// Screen effects
	var flashColor = comboCounter > 3 ? 0xff0000 : 0xffffff;
	var flashDuration = Math.min(comboCounter * 100 + 200, 800);
	LK.effects.flashScreen(flashColor, flashDuration);
	// Update score
	var points = uniqueBlocks.length * 10 * comboMultiplier;
	LK.setScore(LK.getScore() + Math.floor(points));
	scoreTxt.setText(LK.getScore());
	// Update combo display
	if (comboCounter > 1) {
		comboTxt.setText("COMBO x" + comboCounter);
		tween(comboTxt, {
			scaleX: 1.5,
			scaleY: 1.5
		}, {
			duration: 200
		});
		tween(comboTxt, {
			scaleX: 1,
			scaleY: 1
		}, {
			duration: 200
		});
	} else {
		comboTxt.setText("");
	}
	// Play sound
	if (comboCounter > 2) {
		LK.getSound('comboClear').play();
	} else {
		LK.getSound('lineClear').play();
	}
}
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 (draggedPiece) {
		draggedPiece.x = x;
		draggedPiece.y = y;
		var gridPos = getGridPosition(x, y);
		showPreview(draggedPiece, gridPos.x, gridPos.y);
	}
};
game.up = function (x, y, obj) {
	if (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 || draggedPiece.x,
				y: draggedPiece.originalY || draggedPiece.y,
				alpha: 1
			}, {
				duration: 300
			});
		}
		clearPreview();
		draggedPiece.isDragging = false;
		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
	if (Date.now() - lastClearTime > 2000 && comboCounter > 0) {
		comboCounter = 0;
		comboTxt.setText("");
	}
	// Check game over
	if (currentPieces.length > 0 && checkGameOver()) {
		LK.showGameOver();
	}
};
// Initialize game
createNewPieces();
LK.playMusic('bgmusic');

===================================================================
--- original.js
+++ change.js
@@ -244,11 +244,14 @@
 	}
 }
 function checkLines() {
 	var clearedBlocks = [];
-	// Check 3x3 squares only
+	// Check 3x3 squares only at corners and edges
 	for (var i = 0; i <= GRID_SIZE - 3; i++) {
 		for (var j = 0; j <= GRID_SIZE - 3; j++) {
+			// Only check positions that are at corners or edges
+			var isCornerOrEdge = i === 0 || i === GRID_SIZE - 3 || j === 0 || j === GRID_SIZE - 3;
+			if (!isCornerOrEdge) continue;
 			var complete = true;
 			for (var di = 0; di < 3; di++) {
 				for (var dj = 0; dj < 3; dj++) {
 					if (gameGrid[i + di][j + dj] === null) {