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

/**** 
* Classes
****/ 
var ChessPiece = Container.expand(function (type, color, row, col) {
	var self = Container.call(this);
	self.pieceType = type;
	self.pieceColor = color; // 0 = white, 1 = black
	self.boardRow = row;
	self.boardCol = col;
	self.hasMoved = false;
	self.isPromoted = false; // Track permanent promotion status for vizier
	var pieceGraphics = self.attachAsset(type, {
		anchorX: 0.5,
		anchorY: 0.5
	});
	if (color === 1) {
		pieceGraphics.tint = 0x333333;
	}
	self.moveTo = function (newRow, newCol) {
		self.boardRow = newRow;
		self.boardCol = newCol;
		self.hasMoved = true;
		var boardPos = getBoardPosition(newRow, newCol);
		tween(self, {
			x: boardPos.x,
			y: boardPos.y
		}, {
			duration: 300
		});
	};
	self.getRawMoves = function () {
		var moves = [];
		var directions = [];
		switch (self.pieceType) {
			case 'pawn':
				var direction = self.pieceColor === 0 ? -1 : 1;
				var startRow = self.pieceColor === 0 ? 7 : 2;
				// Forward move
				if (isValidSquare(self.boardRow + direction, self.boardCol) && !getPieceAt(self.boardRow + direction, self.boardCol)) {
					moves.push({
						row: self.boardRow + direction,
						col: self.boardCol
					});
					// Double move from start
					if (self.boardRow === startRow && !getPieceAt(self.boardRow + 2 * direction, self.boardCol)) {
						moves.push({
							row: self.boardRow + 2 * direction,
							col: self.boardCol
						});
					}
				}
				// Diagonal captures
				for (var dc = -1; dc <= 1; dc += 2) {
					var newRow = self.boardRow + direction;
					var newCol = self.boardCol + dc;
					if (isValidSquare(newRow, newCol)) {
						var piece = getPieceAt(newRow, newCol);
						if (piece && piece.pieceColor !== self.pieceColor) {
							moves.push({
								row: newRow,
								col: newCol
							});
						}
					}
					// En passant
					if (lastMove && lastMove.piece.pieceType === 'pawn' && Math.abs(lastMove.fromRow - lastMove.toRow) === 2) {
						if (lastMove.toRow === self.boardRow && Math.abs(lastMove.toCol - self.boardCol) === 1) {
							moves.push({
								row: self.boardRow + direction,
								col: lastMove.toCol,
								isEnPassant: true,
								captureRow: lastMove.toRow,
								captureCol: lastMove.toCol
							});
						}
					}
				}
				break;
			case 'rook':
				directions = [{
					dr: 0,
					dc: 1
				}, {
					dr: 0,
					dc: -1
				}, {
					dr: 1,
					dc: 0
				}, {
					dr: -1,
					dc: 0
				}];
				for (var i = 0; i < directions.length; i++) {
					var dir = directions[i];
					for (var dist = 1; dist < 11; dist++) {
						var newRow = self.boardRow + dir.dr * dist;
						var newCol = self.boardCol + dir.dc * dist;
						if (!isValidSquare(newRow, newCol)) {
							break;
						}
						var piece = getPieceAt(newRow, newCol);
						if (piece) {
							if (piece.pieceColor !== self.pieceColor) {
								moves.push({
									row: newRow,
									col: newCol
								});
							}
							break;
						}
						moves.push({
							row: newRow,
							col: newCol
						});
					}
				}
				break;
			case 'bishop':
				// Bishop can move one square orthogonally (row/column only)
				var oneSquareOrthogonalDirections = [{
					dr: 0,
					dc: 1
				}, {
					dr: 0,
					dc: -1
				}, {
					dr: 1,
					dc: 0
				}, {
					dr: -1,
					dc: 0
				}];
				// Add one square moves in orthogonal directions only
				for (var i = 0; i < oneSquareOrthogonalDirections.length; i++) {
					var dir = oneSquareOrthogonalDirections[i];
					var newRow = self.boardRow + dir.dr;
					var newCol = self.boardCol + dir.dc;
					if (isValidSquare(newRow, newCol)) {
						var piece = getPieceAt(newRow, newCol);
						if (!piece || piece.pieceColor !== self.pieceColor) {
							moves.push({
								row: newRow,
								col: newCol
							});
						}
					}
				}
				// Bishop can also move as many squares as wanted diagonally (minimum 2) without jumping over friendly pieces
				var diagonalDirections = [{
					dr: 1,
					dc: 1
				}, {
					dr: 1,
					dc: -1
				}, {
					dr: -1,
					dc: 1
				}, {
					dr: -1,
					dc: -1
				}];
				for (var i = 0; i < diagonalDirections.length; i++) {
					var dir = diagonalDirections[i];
					for (var dist = 2; dist < 11; dist++) {
						var newRow = self.boardRow + dir.dr * dist;
						var newCol = self.boardCol + dir.dc * dist;
						if (!isValidSquare(newRow, newCol)) {
							break;
						}
						// Check if path is blocked by any piece (friendly or enemy)
						var pathBlocked = false;
						for (var checkDist = 1; checkDist < dist; checkDist++) {
							var checkRow = self.boardRow + dir.dr * checkDist;
							var checkCol = self.boardCol + dir.dc * checkDist;
							var pathPiece = getPieceAt(checkRow, checkCol);
							if (pathPiece) {
								pathBlocked = true;
								break;
							}
						}
						if (pathBlocked) {
							break;
						}
						var piece = getPieceAt(newRow, newCol);
						if (piece) {
							if (piece.pieceColor !== self.pieceColor) {
								moves.push({
									row: newRow,
									col: newCol
								});
							}
							break;
						}
						moves.push({
							row: newRow,
							col: newCol
						});
					}
				}
				break;
			case 'queen':
				// Vizier: restricted to one square, enhanced to eight squares when promoted
				// Diagonal movement is closed at the beginning (only orthogonal moves allowed)
				// When promoted, both orthogonal and diagonal moves are allowed
				if (self.isPromoted) {
					directions = [{
						dr: 0,
						dc: 1
					}, {
						dr: 0,
						dc: -1
					}, {
						dr: 1,
						dc: 0
					}, {
						dr: -1,
						dc: 0
					}, {
						dr: 1,
						dc: 1
					}, {
						dr: 1,
						dc: -1
					}, {
						dr: -1,
						dc: 1
					}, {
						dr: -1,
						dc: -1
					}];
				} else {
					// Only orthogonal moves at the beginning (diagonals closed)
					directions = [{
						dr: 0,
						dc: 1
					}, {
						dr: 0,
						dc: -1
					}, {
						dr: 1,
						dc: 0
					}, {
						dr: -1,
						dc: 0
					}];
				}
				var maxDistance = self.isPromoted ? 8 : 1;
				for (var i = 0; i < directions.length; i++) {
					var dir = directions[i];
					for (var dist = 1; dist <= maxDistance; dist++) {
						var newRow = self.boardRow + dir.dr * dist;
						var newCol = self.boardCol + dir.dc * dist;
						if (!isValidSquare(newRow, newCol)) {
							break;
						}
						var piece = getPieceAt(newRow, newCol);
						if (piece) {
							if (piece.pieceColor !== self.pieceColor) {
								moves.push({
									row: newRow,
									col: newCol
								});
							}
							break;
						}
						moves.push({
							row: newRow,
							col: newCol
						});
					}
				}
				break;
			case 'king':
				directions = [{
					dr: 0,
					dc: 1
				}, {
					dr: 0,
					dc: -1
				}, {
					dr: 1,
					dc: 0
				}, {
					dr: -1,
					dc: 0
				}, {
					dr: 1,
					dc: 1
				}, {
					dr: 1,
					dc: -1
				}, {
					dr: -1,
					dc: 1
				}, {
					dr: -1,
					dc: -1
				}];
				for (var i = 0; i < directions.length; i++) {
					var dir = directions[i];
					var newRow = self.boardRow + dir.dr;
					var newCol = self.boardCol + dir.dc;
					if (isValidSquare(newRow, newCol)) {
						var piece = getPieceAt(newRow, newCol);
						if (!piece || piece.pieceColor !== self.pieceColor) {
							moves.push({
								row: newRow,
								col: newCol
							});
						}
					}
				}
				break;
			case 'knight':
				var knightMoves = [{
					dr: 2,
					dc: 1
				}, {
					dr: 2,
					dc: -1
				}, {
					dr: -2,
					dc: 1
				}, {
					dr: -2,
					dc: -1
				}, {
					dr: 1,
					dc: 2
				}, {
					dr: 1,
					dc: -2
				}, {
					dr: -1,
					dc: 2
				}, {
					dr: -1,
					dc: -2
				}];
				for (var i = 0; i < knightMoves.length; i++) {
					var move = knightMoves[i];
					var newRow = self.boardRow + move.dr;
					var newCol = self.boardCol + move.dc;
					if (isValidSquare(newRow, newCol)) {
						var piece = getPieceAt(newRow, newCol);
						if (!piece || piece.pieceColor !== self.pieceColor) {
							moves.push({
								row: newRow,
								col: newCol
							});
						}
					}
				}
				break;
			case 'warElephant':
				// Moves 1 or 2 steps row, column, and diagonal with jumping ability
				directions = [{
					dr: 0,
					dc: 1
				}, {
					dr: 0,
					dc: -1
				}, {
					dr: 1,
					dc: 0
				}, {
					dr: -1,
					dc: 0
				}, {
					dr: 1,
					dc: 1
				}, {
					dr: 1,
					dc: -1
				}, {
					dr: -1,
					dc: 1
				}, {
					dr: -1,
					dc: -1
				}];
				for (var i = 0; i < directions.length; i++) {
					var dir = directions[i];
					for (var dist = 1; dist <= 2; dist++) {
						var newRow = self.boardRow + dir.dr * dist;
						var newCol = self.boardCol + dir.dc * dist;
						if (!isValidSquare(newRow, newCol)) {
							break;
						}
						var piece = getPieceAt(newRow, newCol);
						if (!piece || piece.pieceColor !== self.pieceColor) {
							moves.push({
								row: newRow,
								col: newCol
							});
						}
					}
				}
				break;
			case 'siegeTower':
				// Must move 1 square in row/column, then 1 square diagonally
				// If friendly piece in path, can move 1 step in row/column
				// Captures enemy pieces in its path
				var orthogonalDirections = [{
					dr: 1,
					dc: 0
				}, {
					dr: -1,
					dc: 0
				}, {
					dr: 0,
					dc: 1
				}, {
					dr: 0,
					dc: -1
				}];
				var diagonalDirections = [{
					dr: 1,
					dc: 1
				}, {
					dr: 1,
					dc: -1
				}, {
					dr: -1,
					dc: 1
				}, {
					dr: -1,
					dc: -1
				}];
				// Try L-shaped moves: orthogonal then diagonal
				for (var i = 0; i < orthogonalDirections.length; i++) {
					var orthDir = orthogonalDirections[i];
					var firstRow = self.boardRow + orthDir.dr;
					var firstCol = self.boardCol + orthDir.dc;
					if (!isValidSquare(firstRow, firstCol)) {
						continue;
					}
					var firstPiece = getPieceAt(firstRow, firstCol);
					// If friendly piece blocks first step, can only move orthogonally
					if (firstPiece && firstPiece.pieceColor === self.pieceColor) {
						// Can't move through friendly piece, skip this direction
						continue;
					}
					// Try diagonal moves from the orthogonal position
					for (var j = 0; j < diagonalDirections.length; j++) {
						var diagDir = diagonalDirections[j];
						var finalRow = firstRow + diagDir.dr;
						var finalCol = firstCol + diagDir.dc;
						if (!isValidSquare(finalRow, finalCol)) {
							continue;
						}
						var finalPiece = getPieceAt(finalRow, finalCol);
						if (!finalPiece || finalPiece.pieceColor !== self.pieceColor) {
							var moveData = {
								row: finalRow,
								col: finalCol,
								capturesInPath: []
							};
							// Add captured pieces in path
							if (firstPiece && firstPiece.pieceColor !== self.pieceColor) {
								moveData.capturesInPath.push({
									row: firstRow,
									col: firstCol
								});
							}
							if (finalPiece && finalPiece.pieceColor !== self.pieceColor) {
								moveData.capturesInPath.push({
									row: finalRow,
									col: finalCol
								});
							}
							moves.push(moveData);
						}
					}
				}
				// If friendly piece in orthogonal path, allow simple orthogonal move
				for (var i = 0; i < orthogonalDirections.length; i++) {
					var orthDir = orthogonalDirections[i];
					var newRow = self.boardRow + orthDir.dr;
					var newCol = self.boardCol + orthDir.dc;
					if (!isValidSquare(newRow, newCol)) {
						continue;
					}
					var piece = getPieceAt(newRow, newCol);
					if (!piece || piece.pieceColor !== self.pieceColor) {
						moves.push({
							row: newRow,
							col: newCol
						});
					}
				}
				break;
			case 'minister':
				// Minister: 1 square diagonally, when promoted moves like rook and knight with jumping
				if (self.isPromoted) {
					// Rook-like moves (can jump over pieces when promoted)
					var rookDirections = [{
						dr: 0,
						dc: 1
					}, {
						dr: 0,
						dc: -1
					}, {
						dr: 1,
						dc: 0
					}, {
						dr: -1,
						dc: 0
					}];
					for (var i = 0; i < rookDirections.length; i++) {
						var dir = rookDirections[i];
						for (var dist = 1; dist < 11; dist++) {
							var newRow = self.boardRow + dir.dr * dist;
							var newCol = self.boardCol + dir.dc * dist;
							if (!isValidSquare(newRow, newCol)) {
								break;
							}
							var piece = getPieceAt(newRow, newCol);
							if (piece) {
								if (piece.pieceColor !== self.pieceColor) {
									moves.push({
										row: newRow,
										col: newCol
									});
								}
								break;
							}
							moves.push({
								row: newRow,
								col: newCol
							});
						}
					}
					// Knight-like moves (can jump over pieces)
					var knightMoves = [{
						dr: 2,
						dc: 1
					}, {
						dr: 2,
						dc: -1
					}, {
						dr: -2,
						dc: 1
					}, {
						dr: -2,
						dc: -1
					}, {
						dr: 1,
						dc: 2
					}, {
						dr: 1,
						dc: -2
					}, {
						dr: -1,
						dc: 2
					}, {
						dr: -1,
						dc: -2
					}];
					for (var i = 0; i < knightMoves.length; i++) {
						var move = knightMoves[i];
						var newRow = self.boardRow + move.dr;
						var newCol = self.boardCol + move.dc;
						if (isValidSquare(newRow, newCol)) {
							var piece = getPieceAt(newRow, newCol);
							if (!piece || piece.pieceColor !== self.pieceColor) {
								moves.push({
									row: newRow,
									col: newCol
								});
							}
						}
					}
				} else {
					// Standard minister: 1 square diagonally
					directions = [{
						dr: 1,
						dc: 1
					}, {
						dr: 1,
						dc: -1
					}, {
						dr: -1,
						dc: 1
					}, {
						dr: -1,
						dc: -1
					}];
					for (var i = 0; i < directions.length; i++) {
						var dir = directions[i];
						var newRow = self.boardRow + dir.dr;
						var newCol = self.boardCol + dir.dc;
						if (isValidSquare(newRow, newCol)) {
							var piece = getPieceAt(newRow, newCol);
							if (!piece || piece.pieceColor !== self.pieceColor) {
								moves.push({
									row: newRow,
									col: newCol
								});
							}
						}
					}
				}
				break;
			case 'royalGuard':
				// Up to 3 squares diagonally with blockage of friendly pieces
				var diagonalDirections = [{
					dr: 1,
					dc: 1
				}, {
					dr: 1,
					dc: -1
				}, {
					dr: -1,
					dc: 1
				}, {
					dr: -1,
					dc: -1
				}];
				for (var i = 0; i < diagonalDirections.length; i++) {
					var dir = diagonalDirections[i];
					for (var dist = 1; dist <= 3; dist++) {
						var newRow = self.boardRow + dir.dr * dist;
						var newCol = self.boardCol + dir.dc * dist;
						if (!isValidSquare(newRow, newCol)) {
							break;
						}
						var piece = getPieceAt(newRow, newCol);
						if (piece) {
							if (piece.pieceColor !== self.pieceColor) {
								moves.push({
									row: newRow,
									col: newCol
								});
							}
							break;
						}
						moves.push({
							row: newRow,
							col: newCol
						});
					}
				}
				// Only 2 squares along rows and columns (no 1-step moves)
				var orthogonalDirections = [{
					dr: 0,
					dc: 1
				}, {
					dr: 0,
					dc: -1
				}, {
					dr: 1,
					dc: 0
				}, {
					dr: -1,
					dc: 0
				}];
				for (var i = 0; i < orthogonalDirections.length; i++) {
					var dir = orthogonalDirections[i];
					// Only allow 2-step moves in orthogonal directions
					var dist = 2;
					var newRow = self.boardRow + dir.dr * dist;
					var newCol = self.boardCol + dir.dc * dist;
					if (isValidSquare(newRow, newCol)) {
						var piece = getPieceAt(newRow, newCol);
						if (!piece || piece.pieceColor !== self.pieceColor) {
							moves.push({
								row: newRow,
								col: newCol
							});
						}
					}
				}
				// Forward or backward L-shaped moves (no left/right L moves)
				var lShapeMoves = [
				// Forward L-shapes
				{
					dr: -2,
					dc: 1
				}, {
					dr: -2,
					dc: -1
				},
				// Backward L-shapes
				{
					dr: 2,
					dc: 1
				}, {
					dr: 2,
					dc: -1
				}];
				for (var i = 0; i < lShapeMoves.length; i++) {
					var move = lShapeMoves[i];
					var newRow = self.boardRow + move.dr;
					var newCol = self.boardCol + move.dc;
					if (isValidSquare(newRow, newCol)) {
						var piece = getPieceAt(newRow, newCol);
						if (!piece || piece.pieceColor !== self.pieceColor) {
							moves.push({
								row: newRow,
								col: newCol
							});
						}
					}
				}
				break;
			case 'giraffe':
				// Giraffe: one diagonal move followed by 3-10 straight moves with obstacle checking
				var diagonalDirections = [{
					dr: 1,
					dc: 1
				}, {
					dr: 1,
					dc: -1
				}, {
					dr: -1,
					dc: 1
				}, {
					dr: -1,
					dc: -1
				}];
				for (var i = 0; i < diagonalDirections.length; i++) {
					var diagDir = diagonalDirections[i];
					var firstRow = self.boardRow + diagDir.dr;
					var firstCol = self.boardCol + diagDir.dc;
					if (!isValidSquare(firstRow, firstCol)) {
						continue;
					}
					var firstPiece = getPieceAt(firstRow, firstCol);
					if (firstPiece) {
						continue; // First diagonal square must be empty
					}
					// Determine straight directions based on diagonal direction
					var straightDirections = [];
					if (diagDir.dr > 0) {
						straightDirections.push({
							dr: 1,
							dc: 0
						}); // downward
					}
					if (diagDir.dr < 0) {
						straightDirections.push({
							dr: -1,
							dc: 0
						}); // upward
					}
					if (diagDir.dc > 0) {
						straightDirections.push({
							dr: 0,
							dc: 1
						}); // rightward
					}
					if (diagDir.dc < 0) {
						straightDirections.push({
							dr: 0,
							dc: -1
						}); // leftward
					}
					// Try straight moves from 3 to 10 squares in each valid direction
					for (var j = 0; j < straightDirections.length; j++) {
						var straightDir = straightDirections[j];
						for (var step = 3; step <= 10; step++) {
							var newRow = firstRow + straightDir.dr * step;
							var newCol = firstCol + straightDir.dc * step;
							if (!isValidSquare(newRow, newCol)) {
								break;
							}
							// Check if path is clear from diagonal position to target
							var pathClear = true;
							for (var checkStep = 1; checkStep <= step; checkStep++) {
								var checkRow = firstRow + straightDir.dr * checkStep;
								var checkCol = firstCol + straightDir.dc * checkStep;
								var checkPiece = getPieceAt(checkRow, checkCol);
								if (checkPiece) {
									if (checkStep === step && checkPiece.pieceColor !== self.pieceColor) {
										// Can capture enemy piece at final position
										moves.push({
											row: newRow,
											col: newCol
										});
									}
									pathClear = false;
									break;
								}
							}
							if (pathClear) {
								moves.push({
									row: newRow,
									col: newCol
								});
							}
							if (!pathClear) {
								break; // Stop checking longer distances in this direction
							}
						}
					}
				}
				break;
			case 'bull':
				// Bull can move one column forward or backward
				var columnDirections = [{
					dr: 1,
					dc: 0
				}, {
					dr: -1,
					dc: 0
				}];
				for (var i = 0; i < columnDirections.length; i++) {
					var colDir = columnDirections[i];
					var newRow = self.boardRow + colDir.dr;
					var newCol = self.boardCol + colDir.dc;
					if (isValidSquare(newRow, newCol)) {
						var piece = getPieceAt(newRow, newCol);
						if (!piece || piece.pieceColor !== self.pieceColor) {
							moves.push({
								row: newRow,
								col: newCol
							});
						}
					}
				}
				// Bull moves one square forward or backward in column, then unlimited diagonal movement in same direction
				for (var i = 0; i < columnDirections.length; i++) {
					var colDir = columnDirections[i];
					var firstRow = self.boardRow + colDir.dr;
					var firstCol = self.boardCol + colDir.dc;
					if (!isValidSquare(firstRow, firstCol)) {
						continue;
					}
					var firstPiece = getPieceAt(firstRow, firstCol);
					if (firstPiece) {
						continue; // First square must be empty for bull movement
					}
					// From the first square, move diagonally unlimited in the forward/backward direction
					var diagonalDirections = [{
						dr: 1,
						dc: 1
					}, {
						dr: 1,
						dc: -1
					}, {
						dr: -1,
						dc: 1
					}, {
						dr: -1,
						dc: -1
					}];
					for (var j = 0; j < diagonalDirections.length; j++) {
						var diagDir = diagonalDirections[j];
						// Only allow diagonal movement in same forward/backward direction as column move
						if (colDir.dr > 0 && diagDir.dr <= 0 || colDir.dr < 0 && diagDir.dr >= 0) {
							continue; // Skip diagonal directions that don't match column direction
						}
						// Move unlimited squares diagonally from first position
						for (var dist = 1; dist < 11; dist++) {
							var finalRow = firstRow + diagDir.dr * dist;
							var finalCol = firstCol + diagDir.dc * dist;
							if (!isValidSquare(finalRow, finalCol)) {
								break;
							}
							var finalPiece = getPieceAt(finalRow, finalCol);
							if (finalPiece) {
								if (finalPiece.pieceColor !== self.pieceColor) {
									moves.push({
										row: finalRow,
										col: finalCol
									});
								}
								break;
							}
							moves.push({
								row: finalRow,
								col: finalCol
							});
						}
					}
				}
				// Bull can also jump two squares left and right
				var leftRightJumps = [{
					dr: 0,
					dc: 2
				}, {
					dr: 0,
					dc: -2
				}];
				for (var i = 0; i < leftRightJumps.length; i++) {
					var jump = leftRightJumps[i];
					var newRow = self.boardRow + jump.dr;
					var newCol = self.boardCol + jump.dc;
					if (isValidSquare(newRow, newCol)) {
						var piece = getPieceAt(newRow, newCol);
						if (!piece || piece.pieceColor !== self.pieceColor) {
							moves.push({
								row: newRow,
								col: newCol
							});
						}
					}
				}
				break;
			case 'camel':
				// 1 square column and row (orthogonal moves)
				var orthogonalDirections = [{
					dr: 0,
					dc: 1
				}, {
					dr: 0,
					dc: -1
				}, {
					dr: 1,
					dc: 0
				}, {
					dr: -1,
					dc: 0
				}];
				for (var i = 0; i < orthogonalDirections.length; i++) {
					var dir = orthogonalDirections[i];
					var newRow = self.boardRow + dir.dr;
					var newCol = self.boardCol + dir.dc;
					if (isValidSquare(newRow, newCol)) {
						var piece = getPieceAt(newRow, newCol);
						if (!piece || piece.pieceColor !== self.pieceColor) {
							moves.push({
								row: newRow,
								col: newCol
							});
						}
					}
				}
				// 1 square long L (knight-like moves)
				var knightMoves = [{
					dr: 3,
					dc: 1
				}, {
					dr: 3,
					dc: -1
				}, {
					dr: -3,
					dc: 1
				}, {
					dr: -3,
					dc: -1
				}, {
					dr: 1,
					dc: 3
				}, {
					dr: 1,
					dc: -3
				}, {
					dr: -1,
					dc: 3
				}, {
					dr: -1,
					dc: -3
				}];
				for (var i = 0; i < knightMoves.length; i++) {
					var move = knightMoves[i];
					var newRow = self.boardRow + move.dr;
					var newCol = self.boardCol + move.dc;
					if (isValidSquare(newRow, newCol)) {
						var piece = getPieceAt(newRow, newCol);
						if (!piece || piece.pieceColor !== self.pieceColor) {
							moves.push({
								row: newRow,
								col: newCol
							});
						}
					}
				}
				break;
			case 'lion':
				// Lion has three distinct movement patterns:
				// 1. Move 3 squares diagonally in one direction
				// 2. L-shaped moves (forward/backward 2 + right/left 1)
				// 3. Move 2 diagonally + 1 forward/backward
				// 1st Move: 3 squares diagonally (similar to original code)
				var diagonalDirections = [{
					dr: 1,
					dc: 1
				}, {
					dr: 1,
					dc: -1
				}, {
					dr: -1,
					dc: 1
				}, {
					dr: -1,
					dc: -1
				}];
				for (var i = 0; i < diagonalDirections.length; i++) {
					var dir = diagonalDirections[i];
					var pathBlocked = false;
					for (var dist = 1; dist <= 3; dist++) {
						var newRow = self.boardRow + dir.dr * dist;
						var newCol = self.boardCol + dir.dc * dist;
						if (!isValidSquare(newRow, newCol)) {
							break;
						}
						var piece = getPieceAt(newRow, newCol);
						if (piece) {
							if (piece.pieceColor !== self.pieceColor) {
								moves.push({
									row: newRow,
									col: newCol
								});
							}
							break;
						}
						moves.push({
							row: newRow,
							col: newCol
						});
					}
				}
				// 2nd Move: L-shaped moves (forward/backward 2 + right/left 1)
				var lShapeMoves = [{
					dr: -2,
					dc: 1
				}, {
					dr: -2,
					dc: -1
				}, {
					dr: 2,
					dc: 1
				}, {
					dr: 2,
					dc: -1
				}];
				for (var i = 0; i < lShapeMoves.length; i++) {
					var move = lShapeMoves[i];
					var midRow = self.boardRow + move.dr / 2;
					var endRow = self.boardRow + move.dr;
					var endCol = self.boardCol + move.dc;
					// Check if vertical path is clear (first two squares)
					if (!isValidSquare(midRow, self.boardCol) || getPieceAt(midRow, self.boardCol)) {
						continue;
					}
					// Check for diagonal obstacles
					var diagonalBlocked = false;
					if (move.dr < 0) {
						// moving up
						if (move.dc == -1 && getPieceAt(self.boardRow - 1, self.boardCol - 1)) {
							diagonalBlocked = true;
						}
						if (move.dc == 1 && getPieceAt(self.boardRow - 1, self.boardCol + 1)) {
							diagonalBlocked = true;
						}
					} else {
						// moving down
						if (move.dc == -1 && getPieceAt(self.boardRow + 1, self.boardCol - 1)) {
							diagonalBlocked = true;
						}
						if (move.dc == 1 && getPieceAt(self.boardRow + 1, self.boardCol + 1)) {
							diagonalBlocked = true;
						}
					}
					if (diagonalBlocked) {
						continue;
					}
					if (isValidSquare(endRow, endCol)) {
						var piece = getPieceAt(endRow, endCol);
						if (!piece || piece.pieceColor !== self.pieceColor) {
							moves.push({
								row: endRow,
								col: endCol
							});
						}
					}
				}
				// 3rd Move: 2 diagonals + 1 forward/backward
				for (var i = 0; i < diagonalDirections.length; i++) {
					var dir = diagonalDirections[i];
					var pathBlocked = false;
					// Check if we can move 2 squares diagonally
					for (var checkDist = 1; checkDist <= 2; checkDist++) {
						var checkRow = self.boardRow + dir.dr * checkDist;
						var checkCol = self.boardCol + dir.dc * checkDist;
						if (!isValidSquare(checkRow, checkCol)) {
							pathBlocked = true;
							break;
						}
						var pathPiece = getPieceAt(checkRow, checkCol);
						if (pathPiece) {
							pathBlocked = true;
							break;
						}
					}
					if (pathBlocked) {
						continue;
					}
					var twoSquareRow = self.boardRow + dir.dr * 2;
					var twoSquareCol = self.boardCol + dir.dc * 2;
					// Then move 1 square forward or backward
					var verticalMoves = [{
						dr: -1,
						dc: 0
					}, {
						dr: 1,
						dc: 0
					}];
					for (var j = 0; j < verticalMoves.length; j++) {
						var vertMove = verticalMoves[j];
						var finalRow = twoSquareRow + vertMove.dr;
						var finalCol = twoSquareCol + vertMove.dc;
						if (isValidSquare(finalRow, finalCol)) {
							var piece = getPieceAt(finalRow, finalCol);
							if (!piece || piece.pieceColor !== self.pieceColor) {
								moves.push({
									row: finalRow,
									col: finalCol
								});
							}
						}
					}
				}
				// Remove side L-shaped moves from the moves list
				moves = moves.filter(function (move) {
					return !isSideLMove(self.boardRow, self.boardCol, move.row, move.col);
				});
				break;
			case 'pawnOfTheWarMachine':
				var direction = self.pieceColor === 0 ? -1 : 1;
				var startRow = self.pieceColor === 0 ? 7 : 2;
				// Forward move
				if (isValidSquare(self.boardRow + direction, self.boardCol) && !getPieceAt(self.boardRow + direction, self.boardCol)) {
					moves.push({
						row: self.boardRow + direction,
						col: self.boardCol
					});
					// Double move from start
					if (self.boardRow === startRow && !getPieceAt(self.boardRow + 2 * direction, self.boardCol)) {
						moves.push({
							row: self.boardRow + 2 * direction,
							col: self.boardCol
						});
					}
				}
				// Diagonal captures
				for (var dc = -1; dc <= 1; dc += 2) {
					var newRow = self.boardRow + direction;
					var newCol = self.boardCol + dc;
					if (isValidSquare(newRow, newCol)) {
						var piece = getPieceAt(newRow, newCol);
						if (piece && piece.pieceColor !== self.pieceColor) {
							moves.push({
								row: newRow,
								col: newCol
							});
						}
					}
					// En passant
					if (lastMove && lastMove.piece.pieceType === 'pawnOfTheWarMachine' && Math.abs(lastMove.fromRow - lastMove.toRow) === 2) {
						if (lastMove.toRow === self.boardRow && Math.abs(lastMove.toCol - self.boardCol) === 1) {
							moves.push({
								row: self.boardRow + direction,
								col: lastMove.toCol,
								isEnPassant: true,
								captureRow: lastMove.toRow,
								captureCol: lastMove.toCol
							});
						}
					}
				}
				break;
			case 'camelPawn':
				var direction = self.pieceColor === 0 ? -1 : 1;
				var startRow = self.pieceColor === 0 ? 7 : 2;
				// Forward move
				if (isValidSquare(self.boardRow + direction, self.boardCol) && !getPieceAt(self.boardRow + direction, self.boardCol)) {
					moves.push({
						row: self.boardRow + direction,
						col: self.boardCol
					});
					// Double move from start
					if (self.boardRow === startRow && !getPieceAt(self.boardRow + 2 * direction, self.boardCol)) {
						moves.push({
							row: self.boardRow + 2 * direction,
							col: self.boardCol
						});
					}
				}
				// Diagonal captures
				for (var dc = -1; dc <= 1; dc += 2) {
					var newRow = self.boardRow + direction;
					var newCol = self.boardCol + dc;
					if (isValidSquare(newRow, newCol)) {
						var piece = getPieceAt(newRow, newCol);
						if (piece && piece.pieceColor !== self.pieceColor) {
							moves.push({
								row: newRow,
								col: newCol
							});
						}
					}
					// En passant
					if (lastMove && lastMove.piece.pieceType === 'camelPawn' && Math.abs(lastMove.fromRow - lastMove.toRow) === 2) {
						if (lastMove.toRow === self.boardRow && Math.abs(lastMove.toCol - self.boardCol) === 1) {
							moves.push({
								row: self.boardRow + direction,
								col: lastMove.toCol,
								isEnPassant: true,
								captureRow: lastMove.toRow,
								captureCol: lastMove.toCol
							});
						}
					}
				}
				break;
			case 'pawnOfTheElephant':
				var direction = self.pieceColor === 0 ? -1 : 1;
				var startRow = self.pieceColor === 0 ? 7 : 2;
				// Forward move
				if (isValidSquare(self.boardRow + direction, self.boardCol) && !getPieceAt(self.boardRow + direction, self.boardCol)) {
					moves.push({
						row: self.boardRow + direction,
						col: self.boardCol
					});
					// Double move from start
					if (self.boardRow === startRow && !getPieceAt(self.boardRow + 2 * direction, self.boardCol)) {
						moves.push({
							row: self.boardRow + 2 * direction,
							col: self.boardCol
						});
					}
				}
				// Diagonal captures
				for (var dc = -1; dc <= 1; dc += 2) {
					var newRow = self.boardRow + direction;
					var newCol = self.boardCol + dc;
					if (isValidSquare(newRow, newCol)) {
						var piece = getPieceAt(newRow, newCol);
						if (piece && piece.pieceColor !== self.pieceColor) {
							moves.push({
								row: newRow,
								col: newCol
							});
						}
					}
					// En passant
					if (lastMove && lastMove.piece.pieceType === 'pawnOfTheElephant' && Math.abs(lastMove.fromRow - lastMove.toRow) === 2) {
						if (lastMove.toRow === self.boardRow && Math.abs(lastMove.toCol - self.boardCol) === 1) {
							moves.push({
								row: self.boardRow + direction,
								col: lastMove.toCol,
								isEnPassant: true,
								captureRow: lastMove.toRow,
								captureCol: lastMove.toCol
							});
						}
					}
				}
				break;
		}
		return moves;
	};
	self.getValidMoves = function () {
		var moves = self.getRawMoves();
		// Add castling for king after getting raw moves
		if (self.pieceType === 'king' && !self.hasMoved && !isInCheck(self.pieceColor)) {
			// Kingside castling
			var kingsideRook = getPieceAt(self.boardRow, self.boardCol + 3);
			if (kingsideRook && kingsideRook.pieceType === 'rook' && !kingsideRook.hasMoved) {
				var canCastle = true;
				for (var c = self.boardCol + 1; c < self.boardCol + 3; c++) {
					if (getPieceAt(self.boardRow, c) || isSquareAttacked(self.boardRow, c, 1 - self.pieceColor)) {
						canCastle = false;
						break;
					}
				}
				if (canCastle) {
					moves.push({
						row: self.boardRow,
						col: self.boardCol + 2,
						isCastling: true,
						rookFromCol: self.boardCol + 3,
						rookToCol: self.boardCol + 1
					});
				}
			}
			// Queenside castling
			var queensideRook = getPieceAt(self.boardRow, self.boardCol - 4);
			if (queensideRook && queensideRook.pieceType === 'rook' && !queensideRook.hasMoved) {
				var canCastle = true;
				for (var c = self.boardCol - 1; c > self.boardCol - 4; c--) {
					if (getPieceAt(self.boardRow, c) || isSquareAttacked(self.boardRow, c, 1 - self.pieceColor)) {
						canCastle = false;
						break;
					}
				}
				if (canCastle) {
					moves.push({
						row: self.boardRow,
						col: self.boardCol - 2,
						isCastling: true,
						rookFromCol: self.boardCol - 4,
						rookToCol: self.boardCol - 1
					});
				}
			}
		}
		// Filter moves that would leave the king in check
		var validMoves = [];
		for (var i = 0; i < moves.length; i++) {
			if (isValidMoveConsideringCheck(self, moves[i].row, moves[i].col)) {
				validMoves.push(moves[i]);
			}
		}
		return validMoves;
	};
	return self;
});

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

/**** 
* Game Code
****/ 
var BOARD_WIDTH = 11;
var BOARD_HEIGHT = 10;
var SQUARE_SIZE = 180;
var BOARD_START_X = (2048 - BOARD_WIDTH * SQUARE_SIZE) / 2;
var BOARD_START_Y = (2732 - BOARD_HEIGHT * SQUARE_SIZE) / 2;
var boardSquares = [];
var pieces = [];
var selectedPiece = null;
var highlightedSquares = [];
var currentPlayer = 0; // 0 = white, 1 = black
var gameStarted = false;
var lastMove = null;
function getBoardPosition(row, col) {
	return {
		x: BOARD_START_X + col * SQUARE_SIZE + SQUARE_SIZE / 2,
		y: BOARD_START_Y + row * SQUARE_SIZE + SQUARE_SIZE / 2
	};
}
function getBoardCoordinates(x, y) {
	var col = Math.floor((x - BOARD_START_X) / SQUARE_SIZE);
	var row = Math.floor((y - BOARD_START_Y) / SQUARE_SIZE);
	return {
		row: row,
		col: col
	};
}
function isValidSquare(row, col) {
	return row >= 0 && row < BOARD_HEIGHT && col >= 0 && col < BOARD_WIDTH;
}
function getPieceAt(row, col) {
	for (var i = 0; i < pieces.length; i++) {
		if (pieces[i].boardRow === row && pieces[i].boardCol === col) {
			return pieces[i];
		}
	}
	return null;
}
function createBoard() {
	for (var row = 0; row < BOARD_HEIGHT; row++) {
		boardSquares[row] = [];
		for (var col = 0; col < BOARD_WIDTH; col++) {
			var isLight = (row + col) % 2 === 0;
			var square = game.addChild(LK.getAsset(isLight ? 'lightSquare' : 'darkSquare', {
				anchorX: 0.5,
				anchorY: 0.5
			}));
			var pos = getBoardPosition(row, col);
			square.x = pos.x;
			square.y = pos.y;
			square.boardRow = row;
			square.boardCol = col;
			boardSquares[row][col] = square;
		}
	}
}
function createPieces() {
	// Create pieces for both players
	var pieceSetup = [
	// White pieces (bottom)
	{
		type: 'rook',
		color: 0,
		row: 8,
		col: 0
	}, {
		type: 'knight',
		color: 0,
		row: 8,
		col: 1
	}, {
		type: 'warElephant',
		color: 0,
		row: 9,
		col: 0
	}, {
		type: 'warElephant',
		color: 0,
		row: 9,
		col: 10
	}, {
		type: 'bishop',
		color: 0,
		row: 8,
		col: 2
	}, {
		type: 'minister',
		color: 0,
		row: 8,
		col: 4
	}, {
		type: 'king',
		color: 0,
		row: 8,
		col: 5
	}, {
		type: 'bishop',
		color: 0,
		row: 8,
		col: 8
	}, {
		type: 'siegeTower',
		color: 0,
		row: 9,
		col: 6
	}, {
		type: 'siegeTower',
		color: 0,
		row: 9,
		col: 4
	}, {
		type: 'queen',
		color: 0,
		row: 8,
		col: 6
	}, {
		type: 'giraffe',
		color: 0,
		row: 8,
		col: 3
	}, {
		type: 'giraffe',
		color: 0,
		row: 8,
		col: 7
	}, {
		type: 'knight',
		color: 0,
		row: 8,
		col: 9
	}, {
		type: 'rook',
		color: 0,
		row: 8,
		col: 10
	},
	// White royal guards
	{
		type: 'royalGuard',
		color: 0,
		row: 9,
		col: 5
	},
	// White lions
	{
		type: 'lion',
		color: 0,
		row: 9,
		col: 1
	}, {
		type: 'lion',
		color: 0,
		row: 9,
		col: 9
	},
	// White camels
	{
		type: 'camel',
		color: 0,
		row: 9,
		col: 2
	}, {
		type: 'camel',
		color: 0,
		row: 9,
		col: 8
	},
	// White bulls
	{
		type: 'bull',
		color: 0,
		row: 9,
		col: 3
	}, {
		type: 'bull',
		color: 0,
		row: 9,
		col: 7
	},
	// Black pieces (top)
	{
		type: 'rook',
		color: 1,
		row: 1,
		col: 0
	}, {
		type: 'knight',
		color: 1,
		row: 1,
		col: 1
	}, {
		type: 'warElephant',
		color: 1,
		row: 0,
		col: 0
	}, {
		type: 'warElephant',
		color: 1,
		row: 0,
		col: 10
	}, {
		type: 'bishop',
		color: 1,
		row: 1,
		col: 2
	}, {
		type: 'minister',
		color: 1,
		row: 1,
		col: 6
	}, {
		type: 'king',
		color: 1,
		row: 1,
		col: 5
	}, {
		type: 'bishop',
		color: 1,
		row: 1,
		col: 8
	}, {
		type: 'siegeTower',
		color: 1,
		row: 0,
		col: 6
	}, {
		type: 'siegeTower',
		color: 1,
		row: 0,
		col: 4
	}, {
		type: 'queen',
		color: 1,
		row: 1,
		col: 4
	}, {
		type: 'giraffe',
		color: 1,
		row: 1,
		col: 3
	}, {
		type: 'giraffe',
		color: 1,
		row: 1,
		col: 7
	}, {
		type: 'knight',
		color: 1,
		row: 1,
		col: 9
	}, {
		type: 'rook',
		color: 1,
		row: 1,
		col: 10
	},
	// Black royal guards
	{
		type: 'royalGuard',
		color: 1,
		row: 0,
		col: 5
	},
	// Black lions
	{
		type: 'lion',
		color: 1,
		row: 0,
		col: 1
	}, {
		type: 'lion',
		color: 1,
		row: 0,
		col: 9
	},
	// Black camels
	{
		type: 'camel',
		color: 1,
		row: 0,
		col: 2
	}, {
		type: 'camel',
		color: 1,
		row: 0,
		col: 8
	},
	// Black bulls
	{
		type: 'bull',
		color: 1,
		row: 0,
		col: 3
	}, {
		type: 'bull',
		color: 1,
		row: 0,
		col: 7
	}];
	// Add one Pawn of Pawns for each side
	pieceSetup.push({
		type: 'pawn',
		color: 0,
		row: 7,
		col: 0
	}); // White Pawn of Pawns on far left
	pieceSetup.push({
		type: 'pawn',
		color: 1,
		row: 2,
		col: 10
	}); // Black Pawn of Pawns on far right
	// Add Pawn of the War Machine for each side
	pieceSetup.push({
		type: 'pawnOfTheWarMachine',
		color: 0,
		row: 7,
		col: 1
	}); // White Pawn of the War Machine
	pieceSetup.push({
		type: 'pawnOfTheWarMachine',
		color: 1,
		row: 2,
		col: 9
	}); // Black Pawn of the War Machine
	// Add Camel Pawn for each side
	pieceSetup.push({
		type: 'camelPawn',
		color: 0,
		row: 7,
		col: 2
	}); // White Camel Pawn
	pieceSetup.push({
		type: 'camelPawn',
		color: 1,
		row: 2,
		col: 8
	}); // Black Camel Pawn
	// Add Pawn of the Elephant for each side
	pieceSetup.push({
		type: 'pawnOfTheElephant',
		color: 0,
		row: 7,
		col: 3
	}); // White Pawn of the Elephant
	pieceSetup.push({
		type: 'pawnOfTheElephant',
		color: 1,
		row: 2,
		col: 7
	}); // Black Pawn of the Elephant
	for (var i = 0; i < pieceSetup.length; i++) {
		var setup = pieceSetup[i];
		var piece = game.addChild(new ChessPiece(setup.type, setup.color, setup.row, setup.col));
		var pos = getBoardPosition(setup.row, setup.col);
		piece.x = pos.x;
		piece.y = pos.y;
		pieces.push(piece);
	}
}
function clearHighlights() {
	for (var i = 0; i < highlightedSquares.length; i++) {
		highlightedSquares[i].destroy();
	}
	highlightedSquares = [];
}
function highlightMoves(moves) {
	clearHighlights();
	for (var i = 0; i < moves.length; i++) {
		var move = moves[i];
		var highlight = game.addChild(LK.getAsset('highlightSquare', {
			anchorX: 0.5,
			anchorY: 0.5,
			alpha: 0.5
		}));
		var pos = getBoardPosition(move.row, move.col);
		highlight.x = pos.x;
		highlight.y = pos.y;
		highlightedSquares.push(highlight);
	}
}
function selectPiece(piece) {
	if (selectedPiece) {
		selectedPiece.removeChild(selectedPiece.selectionHighlight);
		selectedPiece.selectionHighlight = null;
	}
	selectedPiece = piece;
	if (piece) {
		piece.selectionHighlight = piece.addChild(LK.getAsset('selectedSquare', {
			anchorX: 0.5,
			anchorY: 0.5,
			alpha: 0.3
		}));
		var validMoves = piece.getValidMoves();
		highlightMoves(validMoves);
	} else {
		clearHighlights();
	}
}
function makeMove(piece, targetRow, targetCol, moveData) {
	var originalRow = piece.boardRow;
	var originalCol = piece.boardCol;
	var capturedPiece = null;
	var capturedPieces = [];
	// Handle special moves
	if (moveData && moveData.isCastling) {
		// Move the rook for castling
		var rook = getPieceAt(originalRow, moveData.rookFromCol);
		if (rook) {
			rook.moveTo(originalRow, moveData.rookToCol);
		}
	} else if (moveData && moveData.isEnPassant) {
		// Capture the pawn for en passant
		capturedPiece = getPieceAt(moveData.captureRow, moveData.captureCol);
		if (capturedPiece) {
			capturedPieces.push(capturedPiece);
		}
	} else if (moveData && moveData.capturesInPath) {
		// Handle siegeTower path captures
		for (var k = 0; k < moveData.capturesInPath.length; k++) {
			var capturePos = moveData.capturesInPath[k];
			var pathPiece = getPieceAt(capturePos.row, capturePos.col);
			if (pathPiece) {
				capturedPieces.push(pathPiece);
			}
		}
	} else {
		capturedPiece = getPieceAt(targetRow, targetCol);
		if (capturedPiece) {
			capturedPieces.push(capturedPiece);
		}
	}
	// Remove all captured pieces
	for (var k = 0; k < capturedPieces.length; k++) {
		var capPiece = capturedPieces[k];
		var index = pieces.indexOf(capPiece);
		if (index > -1) {
			pieces.splice(index, 1);
		}
		capPiece.destroy();
	}
	if (capturedPieces.length > 0) {
		LK.getSound('capture').play();
	} else {
		LK.getSound('move').play();
	}
	// Store move for en passant detection
	lastMove = {
		piece: piece,
		fromRow: originalRow,
		fromCol: originalCol,
		toRow: targetRow,
		toCol: targetCol
	};
	piece.moveTo(targetRow, targetCol);
	// Check for vizier promotion
	if (piece.pieceType === 'queen' && !piece.isPromoted) {
		var opponentLastRow = piece.pieceColor === 0 ? 0 : BOARD_HEIGHT - 1;
		if (targetRow === opponentLastRow) {
			piece.isPromoted = true;
			// Visual feedback for promotion
			LK.effects.flashObject(piece, 0xFFD700, 1000); // Flash gold
		}
	}
	// Check for minister promotion
	if (piece.pieceType === 'minister' && !piece.isPromoted) {
		var opponentLastRow = piece.pieceColor === 0 ? 0 : BOARD_HEIGHT - 1;
		if (targetRow === opponentLastRow) {
			piece.isPromoted = true;
			// Visual feedback for promotion
			LK.effects.flashObject(piece, 0x9932CC, 1000); // Flash purple
		}
	}
	// Check for Pawn of the War Machine promotion
	if (piece.pieceType === 'pawnOfTheWarMachine') {
		var opponentLastRow = piece.pieceColor === 0 ? 0 : BOARD_HEIGHT - 1;
		if (targetRow === opponentLastRow) {
			// Transform into siege tower
			piece.pieceType = 'siegeTower';
			// Change texture to siege tower
			piece.removeChildAt(0); // Remove old texture
			var siegeTowerGraphics = piece.attachAsset('siegeTower', {
				anchorX: 0.5,
				anchorY: 0.5
			});
			if (piece.pieceColor === 1) {
				siegeTowerGraphics.tint = 0x333333;
			}
			// Visual feedback for promotion
			LK.effects.flashObject(piece, 0x00FF00, 1000); // Flash green
		}
	}
	// Check for Camel Pawn promotion
	if (piece.pieceType === 'camelPawn') {
		var opponentLastRow = piece.pieceColor === 0 ? 0 : BOARD_HEIGHT - 1;
		if (targetRow === opponentLastRow) {
			// Transform into camel
			piece.pieceType = 'camel';
			// Change texture to camel
			piece.removeChildAt(0); // Remove old texture
			var camelGraphics = piece.attachAsset('camel', {
				anchorX: 0.5,
				anchorY: 0.5
			});
			if (piece.pieceColor === 1) {
				camelGraphics.tint = 0x333333;
			}
			// Visual feedback for promotion
			LK.effects.flashObject(piece, 0xFFFF00, 1000); // Flash yellow
		}
	}
	// Check for Pawn of the Elephant promotion
	if (piece.pieceType === 'pawnOfTheElephant') {
		var opponentLastRow = piece.pieceColor === 0 ? 0 : BOARD_HEIGHT - 1;
		if (targetRow === opponentLastRow) {
			// Transform into war elephant
			piece.pieceType = 'warElephant';
			// Change texture to war elephant
			piece.removeChildAt(0); // Remove old texture
			var warElephantGraphics = piece.attachAsset('warElephant', {
				anchorX: 0.5,
				anchorY: 0.5
			});
			if (piece.pieceColor === 1) {
				warElephantGraphics.tint = 0x333333;
			}
			// Visual feedback for promotion
			LK.effects.flashObject(piece, 0x8B4513, 1000); // Flash brown
		}
	}
	currentPlayer = 1 - currentPlayer;
	selectPiece(null);
	// Check for victory conditions
	checkGameEnd();
}
function isSquareAttacked(row, col, byColor) {
	for (var i = 0; i < pieces.length; i++) {
		var piece = pieces[i];
		if (piece.pieceColor !== byColor) {
			continue;
		}
		var moves = piece.getRawMoves();
		for (var j = 0; j < moves.length; j++) {
			if (moves[j].row === row && moves[j].col === col) {
				return true;
			}
		}
	}
	return false;
}
function findKing(color) {
	for (var i = 0; i < pieces.length; i++) {
		if (pieces[i].pieceType === 'king' && pieces[i].pieceColor === color) {
			return pieces[i];
		}
	}
	return null;
}
function isInCheck(color) {
	var king = findKing(color);
	if (!king) {
		return false;
	}
	return isSquareAttacked(king.boardRow, king.boardCol, 1 - color);
}
function isValidMoveConsideringCheck(piece, targetRow, targetCol) {
	// Simulate the move
	var originalRow = piece.boardRow;
	var originalCol = piece.boardCol;
	var capturedPiece = getPieceAt(targetRow, targetCol);
	var capturedIndex = -1;
	if (capturedPiece) {
		capturedIndex = pieces.indexOf(capturedPiece);
		pieces.splice(capturedIndex, 1);
	}
	piece.boardRow = targetRow;
	piece.boardCol = targetCol;
	var stillInCheck = isInCheck(piece.pieceColor);
	// Restore the position
	piece.boardRow = originalRow;
	piece.boardCol = originalCol;
	if (capturedPiece && capturedIndex > -1) {
		pieces.splice(capturedIndex, 0, capturedPiece);
	}
	return !stillInCheck;
}
function hasValidMoves(color) {
	for (var i = 0; i < pieces.length; i++) {
		var piece = pieces[i];
		if (piece.pieceColor !== color) {
			continue;
		}
		var moves = piece.getRawMoves();
		for (var j = 0; j < moves.length; j++) {
			if (isValidMoveConsideringCheck(piece, moves[j].row, moves[j].col)) {
				return true;
			}
		}
	}
	return false;
}
function isSideLMove(fromRow, fromCol, toRow, toCol) {
	var rowDiff = Math.abs(toRow - fromRow);
	var colDiff = Math.abs(toCol - fromCol);
	// Yan L: 2 yatay (col), 1 dikey (row)
	if (rowDiff === 1 && colDiff === 2) {
		return true; // Bu hareket yan L hareketidir
	}
	return false;
}
function checkGameEnd() {
	var whiteKing = findKing(0);
	var blackKing = findKing(1);
	if (!whiteKing) {
		LK.setScore(1);
		LK.showGameOver();
		return;
	}
	if (!blackKing) {
		LK.setScore(1);
		LK.showGameOver();
		return;
	}
	var inCheck = isInCheck(currentPlayer);
	var hasValid = hasValidMoves(currentPlayer);
	if (!hasValid) {
		if (inCheck) {
			// Checkmate
			LK.setScore(1);
			LK.showGameOver();
		} else {
			// Stalemate
			LK.setScore(0);
			LK.showGameOver();
		}
	}
}
function initializeGame() {
	createBoard();
	createPieces();
	gameStarted = true;
}
// Player turn indicator
var turnText = new Text2('White to move', {
	size: 80,
	fill: 0xFFFFFF
});
turnText.anchor.set(0.5, 0);
LK.gui.top.addChild(turnText);
game.down = function (x, y, obj) {
	if (!gameStarted) {
		return;
	}
	var coords = getBoardCoordinates(x, y);
	if (!isValidSquare(coords.row, coords.col)) {
		return;
	}
	var clickedPiece = getPieceAt(coords.row, coords.col);
	if (selectedPiece) {
		var validMoves = selectedPiece.getValidMoves();
		var isValidMove = false;
		for (var i = 0; i < validMoves.length; i++) {
			if (validMoves[i].row === coords.row && validMoves[i].col === coords.col) {
				isValidMove = true;
				break;
			}
		}
		if (isValidMove) {
			var moveData = null;
			for (var i = 0; i < validMoves.length; i++) {
				if (validMoves[i].row === coords.row && validMoves[i].col === coords.col) {
					moveData = validMoves[i];
					break;
				}
			}
			makeMove(selectedPiece, coords.row, coords.col, moveData);
			return;
		}
	}
	if (clickedPiece && clickedPiece.pieceColor === currentPlayer) {
		selectPiece(clickedPiece);
	} else {
		selectPiece(null);
	}
};
game.update = function () {
	if (!gameStarted) {
		initializeGame();
	}
	var playerText = currentPlayer === 0 ? 'White to move' : 'Black to move';
	if (isInCheck(currentPlayer)) {
		playerText += ' (Check!)';
	}
	turnText.setText(playerText);
};

===================================================================
--- original.js
+++ change.js
@@ -1409,9 +1409,9 @@
 		color: 0,
 		row: 8,
 		col: 2
 	}, {
-		type: 'queen',
+		type: 'minister',
 		color: 0,
 		row: 8,
 		col: 4
 	}, {
@@ -1434,9 +1434,9 @@
 		color: 0,
 		row: 9,
 		col: 4
 	}, {
-		type: 'minister',
+		type: 'queen',
 		color: 0,
 		row: 8,
 		col: 6
 	}, {
@@ -1529,9 +1529,9 @@
 		color: 1,
 		row: 1,
 		col: 2
 	}, {
-		type: 'queen',
+		type: 'minister',
 		color: 1,
 		row: 1,
 		col: 6
 	}, {
@@ -1554,9 +1554,9 @@
 		color: 1,
 		row: 0,
 		col: 4
 	}, {
-		type: 'minister',
+		type: 'queen',
 		color: 1,
 		row: 1,
 		col: 4
 	}, {