/**** 
* 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
	self.hasTeleported = false; // Track if pawn's pawn has used teleportation
	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
				// Elephant cannot be stopped by any pieces (friendly or enemy)
				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;
						}
						// Elephant ignores all pieces and can move through them
						var piece = getPieceAt(newRow, newCol);
						if (!piece || piece.pieceColor !== self.pieceColor) {
							moves.push({
								row: newRow,
								col: newCol
							});
						}
						// Continue moving even if there's a piece - elephant cannot be stopped
					}
				}
				break;
			case 'siegeTower':
				// Must move 1 square in row/column, then 1 square diagonally
				// Captures enemy pieces in its path
				// siegeTower cannot be stopped by enemies
				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);
					// siegeTower cannot be stopped by enemies, but friendly pieces still block
					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 'ministersPawn':
				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 === 'ministersPawn' && 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;
			case 'shahsade':
				// King-like movement: 1 square in any direction
				var kingDirections = [{
					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 < kingDirections.length; i++) {
					var dir = kingDirections[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
							});
						}
					}
				}
				// 2 squares diagonally, horizontally, vertically
				var shahsadeDirections = [{
					dr: 0,
					dc: 2
				}, {
					dr: 0,
					dc: -2
				}, {
					dr: 2,
					dc: 0
				}, {
					dr: -2,
					dc: 0
				}, {
					dr: 2,
					dc: 2
				}, {
					dr: 2,
					dc: -2
				}, {
					dr: -2,
					dc: 2
				}, {
					dr: -2,
					dc: -2
				}];
				for (var i = 0; i < shahsadeDirections.length; i++) {
					var dir = shahsadeDirections[i];
					var newRow = self.boardRow + dir.dr;
					var newCol = self.boardCol + dir.dc;
					if (isValidSquare(newRow, newCol)) {
						// Check if path is blocked by any piece
						var pathBlocked = false;
						var stepRow = dir.dr === 0 ? 0 : dir.dr > 0 ? 1 : -1;
						var stepCol = dir.dc === 0 ? 0 : dir.dc > 0 ? 1 : -1;
						var checkRow = self.boardRow + stepRow;
						var checkCol = self.boardCol + stepCol;
						var pathPiece = getPieceAt(checkRow, checkCol);
						if (pathPiece) {
							pathBlocked = true;
						}
						if (!pathBlocked) {
							var piece = getPieceAt(newRow, newCol);
							if (!piece || piece.pieceColor !== self.pieceColor) {
								moves.push({
									row: newRow,
									col: newCol
								});
							}
						}
					}
				}
				break;
			case 'adventurousKing':
				// King-like movement: 1 square in any direction
				var kingDirections = [{
					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 < kingDirections.length; i++) {
					var dir = kingDirections[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
							});
						}
					}
				}
				// 2 squares diagonally, horizontally, vertically (adventurous Shah can jump over pieces)
				var adventurousKingDirections = [{
					dr: 0,
					dc: 2
				}, {
					dr: 0,
					dc: -2
				}, {
					dr: 2,
					dc: 0
				}, {
					dr: -2,
					dc: 0
				}, {
					dr: 2,
					dc: 2
				}, {
					dr: 2,
					dc: -2
				}, {
					dr: -2,
					dc: 2
				}, {
					dr: -2,
					dc: -2
				}];
				for (var i = 0; i < adventurousKingDirections.length; i++) {
					var dir = adventurousKingDirections[i];
					var newRow = self.boardRow + dir.dr;
					var newCol = self.boardCol + dir.dc;
					if (isValidSquare(newRow, newCol)) {
						// Adventurous Shah can jump over pieces - no path blocking check
						var piece = getPieceAt(newRow, newCol);
						if (!piece || piece.pieceColor !== self.pieceColor) {
							moves.push({
								row: newRow,
								col: newCol
							});
						}
					}
				}
				break;
			case 'kingsPawn':
				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 === 'kingsPawn' && 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 'viziersPawn':
				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 === 'viziersPawn' && 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 'giraffePawn':
				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 === 'giraffePawn' && 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 'knightPawn':
				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 === 'knightPawn' && 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 'rookPawn':
				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 === 'rookPawn' && 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 'pawnOfTheLeader':
				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 === 'pawnOfTheLeader' && 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 'guardsPawn':
				var direction = self.pieceColor === 0 ? -1 : 1;
				// Forward move (no double move for Guard's Pawn)
				if (isValidSquare(self.boardRow + direction, self.boardCol) && !getPieceAt(self.boardRow + direction, self.boardCol)) {
					moves.push({
						row: self.boardRow + 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 === 'guardsPawn' && 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 'pawnOfTheBull':
				var direction = self.pieceColor === 0 ? -1 : 1;
				// Forward move (no double move for Pawn of the Bull)
				if (isValidSquare(self.boardRow + direction, self.boardCol) && !getPieceAt(self.boardRow + direction, self.boardCol)) {
					moves.push({
						row: self.boardRow + 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 === 'pawnOfTheBull' && 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 'lionsPawn':
				var direction = self.pieceColor === 0 ? -1 : 1;
				// Forward move (no double move for Lion's Pawn)
				if (isValidSquare(self.boardRow + direction, self.boardCol) && !getPieceAt(self.boardRow + direction, self.boardCol)) {
					moves.push({
						row: self.boardRow + 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 === 'lionsPawn' && 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 'pawnsPawn':
				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 === 'pawnsPawn' && 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 - rook is at col + 5 (distance from king to rook)
			var kingsideRook = getPieceAt(self.boardRow, self.boardCol + 5);
			if (kingsideRook && kingsideRook.pieceType === 'rook' && !kingsideRook.hasMoved) {
				var canCastle = true;
				// Check squares between king and rook are empty and not attacked
				for (var c = self.boardCol + 1; c < self.boardCol + 5; 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 + 5,
						rookToCol: self.boardCol + 1
					});
				}
			}
			// Queenside castling - rook is at col - 5 (distance from king to rook)
			var queensideRook = getPieceAt(self.boardRow, self.boardCol - 5);
			if (queensideRook && queensideRook.pieceType === 'rook' && !queensideRook.hasMoved) {
				var canCastle = true;
				// Check squares between king and rook are empty and not attacked
				for (var c = self.boardCol - 1; c > self.boardCol - 5; 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 - 5,
						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;
var shahsadePromoted = [false, false]; // Track if shahsade has been promoted for each player
var pawnsPawnHasUsedSpecialMove = []; // Track which pawn's pawns have used their special move
var pawnsPawnMovementCount = []; // Track how many squares each pawn's pawn has moved
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 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
	// Add Minister's Pawn for each side
	pieceSetup.push({
		type: 'ministersPawn',
		color: 0,
		row: 7,
		col: 4
	}); // White Minister's Pawn
	pieceSetup.push({
		type: 'ministersPawn',
		color: 1,
		row: 2,
		col: 6
	}); // Black Minister's Pawn
	// Add King's Pawn for each side
	pieceSetup.push({
		type: 'kingsPawn',
		color: 0,
		row: 7,
		col: 5
	}); // White King's Pawn
	pieceSetup.push({
		type: 'kingsPawn',
		color: 1,
		row: 2,
		col: 5
	}); // Black King's Pawn
	// Add Vizier's Pawn for each side
	pieceSetup.push({
		type: 'viziersPawn',
		color: 0,
		row: 7,
		col: 6
	}); // White Vizier's Pawn
	pieceSetup.push({
		type: 'viziersPawn',
		color: 1,
		row: 2,
		col: 4
	}); // Black Vizier's Pawn
	// Add Giraffe Pawn for each side
	pieceSetup.push({
		type: 'giraffePawn',
		color: 0,
		row: 7,
		col: 7
	}); // White Giraffe Pawn
	pieceSetup.push({
		type: 'giraffePawn',
		color: 1,
		row: 2,
		col: 3
	}); // Black Giraffe Pawn
	// Add Knight Pawn for each side
	pieceSetup.push({
		type: 'knightPawn',
		color: 0,
		row: 7,
		col: 9
	}); // White Knight Pawn
	pieceSetup.push({
		type: 'knightPawn',
		color: 1,
		row: 2,
		col: 1
	}); // Black Knight Pawn
	// Add Rook Pawn for each side
	pieceSetup.push({
		type: 'rookPawn',
		color: 0,
		row: 7,
		col: 10
	}); // White Rook Pawn
	pieceSetup.push({
		type: 'rookPawn',
		color: 1,
		row: 2,
		col: 0
	}); // Black Rook Pawn
	// Add Pawn of the Leader for each side
	pieceSetup.push({
		type: 'pawnOfTheLeader',
		color: 0,
		row: 7,
		col: 8
	}); // White Pawn of the Leader
	pieceSetup.push({
		type: 'pawnOfTheLeader',
		color: 1,
		row: 2,
		col: 2
	}); // Black Pawn of the Leader
	// Add Guard's Pawn for each side - in front of the King's Pawn
	pieceSetup.push({
		type: 'guardsPawn',
		color: 0,
		row: 6,
		col: 5
	}); // White Guard's Pawn (in front of White King's Pawn)
	pieceSetup.push({
		type: 'guardsPawn',
		color: 1,
		row: 3,
		col: 5
	}); // Black Guard's Pawn (in front of Black King's Pawn)
	// Add Pawn of the Bull for each side - in front of the Pawn of the Leader
	pieceSetup.push({
		type: 'pawnOfTheBull',
		color: 0,
		row: 6,
		col: 8
	}); // White Pawn of the Bull (in front of White Pawn of the Leader)
	pieceSetup.push({
		type: 'pawnOfTheBull',
		color: 1,
		row: 3,
		col: 2
	}); // Black Pawn of the Bull (in front of Black Pawn of the Leader)
	// Add Lion's Pawn for each side - in front of the Camel's Pawn
	pieceSetup.push({
		type: 'lionsPawn',
		color: 0,
		row: 6,
		col: 2
	}); // White Lion's Pawn (in front of White Camel Pawn)
	pieceSetup.push({
		type: 'lionsPawn',
		color: 1,
		row: 3,
		col: 8
	}); // Black Lion's Pawn (in front of Black Camel Pawn)
	// Add regular pawn for each side
	pieceSetup.push({
		type: 'pawn',
		color: 0,
		row: 7,
		col: 0
	}); // White Pawn
	pieceSetup.push({
		type: 'pawn',
		color: 1,
		row: 2,
		col: 10
	}); // Black Pawn
	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 assetName = move.isCastling ? 'castlingSquare' : 'highlightSquare';
		var highlight = game.addChild(LK.getAsset(assetName, {
			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);
	// Track movement for pawn's pawn
	if (piece.pieceType === 'pawnsPawn') {
		for (var mc = 0; mc < pawnsPawnMovementCount.length; mc++) {
			if (pawnsPawnMovementCount[mc].piece === piece) {
				pawnsPawnMovementCount[mc].moves++;
				break;
			}
		}
	}
	// 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 Minister's Pawn promotion
	if (piece.pieceType === 'ministersPawn') {
		var opponentLastRow = piece.pieceColor === 0 ? 0 : BOARD_HEIGHT - 1;
		if (targetRow === opponentLastRow) {
			// Transform into promoted minister
			piece.pieceType = 'minister';
			piece.isPromoted = true;
			// Change texture to minister
			piece.removeChildAt(0); // Remove old texture
			var ministerGraphics = piece.attachAsset('minister', {
				anchorX: 0.5,
				anchorY: 0.5
			});
			if (piece.pieceColor === 1) {
				ministerGraphics.tint = 0x333333;
			}
			// Visual feedback for promotion
			LK.effects.flashObject(piece, 0x9932CC, 1000); // Flash purple
		}
	}
	// 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
		}
	}
	// Check for King's Pawn promotion
	if (piece.pieceType === 'kingsPawn') {
		var opponentLastRow = piece.pieceColor === 0 ? 0 : BOARD_HEIGHT - 1;
		if (targetRow === opponentLastRow) {
			// Transform into shahsade
			piece.pieceType = 'shahsade';
			// Change texture to shahsade
			piece.removeChildAt(0); // Remove old texture
			var shahsadeGraphics = piece.attachAsset('shahsade', {
				anchorX: 0.5,
				anchorY: 0.5
			});
			if (piece.pieceColor === 1) {
				shahsadeGraphics.tint = 0x333333;
			}
			// Visual feedback for promotion
			LK.effects.flashObject(piece, 0xFF4500, 1000); // Flash orange red
		}
	}
	// Check for Vizier's Pawn promotion
	if (piece.pieceType === 'viziersPawn') {
		var opponentLastRow = piece.pieceColor === 0 ? 0 : BOARD_HEIGHT - 1;
		if (targetRow === opponentLastRow) {
			// Transform into promoted vizier
			piece.pieceType = 'queen';
			piece.isPromoted = true;
			// Change texture to queen
			piece.removeChildAt(0); // Remove old texture
			var queenGraphics = piece.attachAsset('queen', {
				anchorX: 0.5,
				anchorY: 0.5
			});
			if (piece.pieceColor === 1) {
				queenGraphics.tint = 0x333333;
			}
			// Visual feedback for promotion
			LK.effects.flashObject(piece, 0xFFD700, 1000); // Flash gold
		}
	}
	// Check for Giraffe Pawn promotion
	if (piece.pieceType === 'giraffePawn') {
		var opponentLastRow = piece.pieceColor === 0 ? 0 : BOARD_HEIGHT - 1;
		if (targetRow === opponentLastRow) {
			// Transform into giraffe
			piece.pieceType = 'giraffe';
			// Change texture to giraffe
			piece.removeChildAt(0); // Remove old texture
			var giraffeGraphics = piece.attachAsset('giraffe', {
				anchorX: 0.5,
				anchorY: 0.5
			});
			if (piece.pieceColor === 1) {
				giraffeGraphics.tint = 0x333333;
			}
			// Visual feedback for promotion
			LK.effects.flashObject(piece, 0xFFA500, 1000); // Flash orange
		}
	}
	// Check for Knight Pawn promotion
	if (piece.pieceType === 'knightPawn') {
		var opponentLastRow = piece.pieceColor === 0 ? 0 : BOARD_HEIGHT - 1;
		if (targetRow === opponentLastRow) {
			// Transform into knight
			piece.pieceType = 'knight';
			// Change texture to knight
			piece.removeChildAt(0); // Remove old texture
			var knightGraphics = piece.attachAsset('knight', {
				anchorX: 0.5,
				anchorY: 0.5
			});
			if (piece.pieceColor === 1) {
				knightGraphics.tint = 0x333333;
			}
			// Visual feedback for promotion
			LK.effects.flashObject(piece, 0x00CED1, 1000); // Flash dark turquoise
		}
	}
	// Check for Rook Pawn promotion
	if (piece.pieceType === 'rookPawn') {
		var opponentLastRow = piece.pieceColor === 0 ? 0 : BOARD_HEIGHT - 1;
		if (targetRow === opponentLastRow) {
			// Transform into rook
			piece.pieceType = 'rook';
			// Change texture to rook
			piece.removeChildAt(0); // Remove old texture
			var rookGraphics = piece.attachAsset('rook', {
				anchorX: 0.5,
				anchorY: 0.5
			});
			if (piece.pieceColor === 1) {
				rookGraphics.tint = 0x333333;
			}
			// Visual feedback for promotion
			LK.effects.flashObject(piece, 0x0000FF, 1000); // Flash blue
		}
	}
	// Check for Pawn of the Leader promotion
	if (piece.pieceType === 'pawnOfTheLeader') {
		var opponentLastRow = piece.pieceColor === 0 ? 0 : BOARD_HEIGHT - 1;
		if (targetRow === opponentLastRow) {
			// Transform into bishop
			piece.pieceType = 'bishop';
			// Change texture to bishop
			piece.removeChildAt(0); // Remove old texture
			var bishopGraphics = piece.attachAsset('bishop', {
				anchorX: 0.5,
				anchorY: 0.5
			});
			if (piece.pieceColor === 1) {
				bishopGraphics.tint = 0x333333;
			}
			// Visual feedback for promotion
			LK.effects.flashObject(piece, 0x800080, 1000); // Flash purple
		}
	}
	// Check for Guard's Pawn promotion
	if (piece.pieceType === 'guardsPawn') {
		var opponentLastRow = piece.pieceColor === 0 ? 0 : BOARD_HEIGHT - 1;
		if (targetRow === opponentLastRow) {
			// Transform into royalGuard
			piece.pieceType = 'royalGuard';
			// Change texture to royalGuard
			piece.removeChildAt(0); // Remove old texture
			var royalGuardGraphics = piece.attachAsset('royalGuard', {
				anchorX: 0.5,
				anchorY: 0.5
			});
			if (piece.pieceColor === 1) {
				royalGuardGraphics.tint = 0x333333;
			}
			// Visual feedback for promotion
			LK.effects.flashObject(piece, 0xCD5C5C, 1000); // Flash indian red
		}
	}
	// Check for Pawn of the Bull promotion
	if (piece.pieceType === 'pawnOfTheBull') {
		var opponentLastRow = piece.pieceColor === 0 ? 0 : BOARD_HEIGHT - 1;
		if (targetRow === opponentLastRow) {
			// Transform into bull
			piece.pieceType = 'bull';
			// Change texture to bull
			piece.removeChildAt(0); // Remove old texture
			var bullGraphics = piece.attachAsset('bull', {
				anchorX: 0.5,
				anchorY: 0.5
			});
			if (piece.pieceColor === 1) {
				bullGraphics.tint = 0x333333;
			}
			// Visual feedback for promotion
			LK.effects.flashObject(piece, 0xB8860B, 1000); // Flash dark goldenrod
		}
	}
	// Check for Lion's Pawn promotion
	if (piece.pieceType === 'lionsPawn') {
		var opponentLastRow = piece.pieceColor === 0 ? 0 : BOARD_HEIGHT - 1;
		if (targetRow === opponentLastRow) {
			// Transform into lion
			piece.pieceType = 'lion';
			// Change texture to lion
			piece.removeChildAt(0); // Remove old texture
			var lionGraphics = piece.attachAsset('lion', {
				anchorX: 0.5,
				anchorY: 0.5
			});
			if (piece.pieceColor === 1) {
				lionGraphics.tint = 0x333333;
			}
			// Visual feedback for promotion
			LK.effects.flashObject(piece, 0xFFD700, 1000); // Flash gold
		}
	}
	// Check for regular pawn promotion to pawn's pawn
	if (piece.pieceType === 'pawn') {
		var opponentLastRow = piece.pieceColor === 0 ? 0 : BOARD_HEIGHT - 1;
		if (targetRow === opponentLastRow) {
			// Transform into pawn's pawn
			piece.pieceType = 'pawnsPawn';
			// Initialize movement count for this pawn's pawn
			pawnsPawnMovementCount.push({
				piece: piece,
				moves: 0
			});
			// Change texture to pawn's pawn
			piece.removeChildAt(0); // Remove old texture
			var pawnsPawnGraphics = piece.attachAsset('pawnsPawn', {
				anchorX: 0.5,
				anchorY: 0.5
			});
			if (piece.pieceColor === 1) {
				pawnsPawnGraphics.tint = 0x333333;
			}
			// Visual feedback for promotion
			LK.effects.flashObject(piece, 0xFF69B4, 1000); // Flash hot pink
		}
	}
	// Check for Pawn's Pawn promotion
	if (piece.pieceType === 'pawnsPawn') {
		var opponentLastRow = piece.pieceColor === 0 ? 0 : BOARD_HEIGHT - 1;
		if (targetRow === opponentLastRow) {
			// Find movement count for this piece
			var moveCount = 0;
			for (var mc = 0; mc < pawnsPawnMovementCount.length; mc++) {
				if (pawnsPawnMovementCount[mc].piece === piece) {
					moveCount = pawnsPawnMovementCount[mc].moves;
					break;
				}
			}
			// Must move at least 1 square to be promoted
			if (moveCount >= 1) {
				// Transform into adventurous king
				piece.pieceType = 'adventurousKing';
				// Change texture to adventurous king
				piece.removeChildAt(0); // Remove old texture
				var adventurousKingGraphics = piece.attachAsset('adventurousKing', {
					anchorX: 0.5,
					anchorY: 0.5
				});
				if (piece.pieceColor === 1) {
					adventurousKingGraphics.tint = 0x333333;
				}
				// Visual feedback for promotion
				LK.effects.flashObject(piece, 0x00FFFF, 1000); // Flash cyan
			}
		}
	}
	// Check for shahsade victory condition - capturing king with shahsade is immediate win
	if (piece.pieceType === 'shahsade' && capturedPieces.length > 0) {
		for (var k = 0; k < capturedPieces.length; k++) {
			if (capturedPieces[k].pieceType === 'king') {
				// Shahsade captured the king - immediate victory
				LK.setScore(1);
				LK.showYouWin();
				return;
			}
		}
	}
	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;
	}
	// Check if the attacking player has a shahsade
	var attackingColor = 1 - color;
	var hasShahsade = false;
	for (var i = 0; i < pieces.length; i++) {
		if (pieces[i].pieceColor === attackingColor && pieces[i].pieceType === 'shahsade') {
			hasShahsade = true;
			break;
		}
	}
	// If attacker has shahsade and it hasn't been promoted, they cannot check the king
	if (hasShahsade && !shahsadePromoted[attackingColor]) {
		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;
	// Convert adventurous king if needed after simulated move
	convertAdventurousKingIfNeeded(piece.pieceColor);
	var stillInCheck = isInCheck(piece.pieceColor);
	var hasImmunity = hasImmunityPiece(piece.pieceColor);
	// Restore the position
	piece.boardRow = originalRow;
	piece.boardCol = originalCol;
	if (capturedPiece && capturedIndex > -1) {
		pieces.splice(capturedIndex, 0, capturedPiece);
	}
	// Player can ignore check only if they have immunity piece
	if (hasImmunity) return true;
	// Otherwise check must be resolved
	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 hasRealKing(color) {
	for (var i = 0; i < pieces.length; i++) {
		if (pieces[i].pieceColor === color && pieces[i].pieceType === 'king') {
			return true;
		}
	}
	return false;
}
function hasAdventurousKing(color) {
	for (var i = 0; i < pieces.length; i++) {
		if (pieces[i].pieceColor === color && pieces[i].pieceType === 'adventurousKing') {
			return true;
		}
	}
	return false;
}
function hasShahsade(color) {
	for (var i = 0; i < pieces.length; i++) {
		if (pieces[i].pieceColor === color && pieces[i].pieceType === 'shahsade') {
			return true;
		}
	}
	return false;
}
function convertAdventurousKingIfNeeded(color) {
	if (hasRealKing(color) || hasShahsade(color)) {
		return;
	}
	for (var r = 0; r < BOARD_HEIGHT; r++) {
		for (var c = 0; c < BOARD_WIDTH; c++) {
			var p = getPieceAt(r, c);
			if (p && p.pieceColor === color && p.pieceType === 'adventurousKing') {
				p.pieceType = 'king';
				// Change texture to king
				p.removeChildAt(0); // Remove old texture
				var kingGraphics = p.attachAsset('king', {
					anchorX: 0.5,
					anchorY: 0.5
				});
				if (p.pieceColor === 1) {
					kingGraphics.tint = 0x333333;
				}
				// Visual feedback for conversion
				LK.effects.flashObject(p, 0xFFD700, 1000); // Flash gold
				console.log('AdventurousKing converted to KING at (' + r + ',' + c + ')');
				return;
			}
		}
	}
}
function checkGameEnd() {
	// Convert adventurous kings if needed for both players
	convertAdventurousKingIfNeeded(0);
	convertAdventurousKingIfNeeded(1);
	var whiteKing = findKing(0);
	var blackKing = findKing(1);
	// Check if a player who brought shahsade into play loses their king
	if (!whiteKing) {
		// White king is captured - check if white has shahsade
		var whiteShahsade = null;
		for (var i = 0; i < pieces.length; i++) {
			if (pieces[i].pieceColor === 0 && pieces[i].pieceType === 'shahsade') {
				whiteShahsade = pieces[i];
				break;
			}
		}
		if (whiteShahsade) {
			// Promote shahsade to new shah (king)
			whiteShahsade.pieceType = 'king';
			// Mark that white's shahsade has been promoted
			shahsadePromoted[0] = true;
			// Change texture to king
			whiteShahsade.removeChildAt(0); // Remove old texture
			var kingGraphics = whiteShahsade.attachAsset('king', {
				anchorX: 0.5,
				anchorY: 0.5
			});
			if (whiteShahsade.pieceColor === 1) {
				kingGraphics.tint = 0x333333;
			}
			// Visual feedback for promotion
			LK.effects.flashObject(whiteShahsade, 0xFFD700, 1000); // Flash gold
			// Check if player is in checkmate after promotion
			if (isInCheck(0) && !hasValidMoves(0)) {
				LK.setScore(1);
				LK.showGameOver();
				return;
			}
			// Game continues, don't end
			return;
		} else {
			LK.setScore(1);
			LK.showGameOver();
			return;
		}
	}
	if (!blackKing) {
		// Black king is captured - check if black has shahsade
		var blackShahsade = null;
		for (var i = 0; i < pieces.length; i++) {
			if (pieces[i].pieceColor === 1 && pieces[i].pieceType === 'shahsade') {
				blackShahsade = pieces[i];
				break;
			}
		}
		if (blackShahsade) {
			// Promote shahsade to new shah (king)
			blackShahsade.pieceType = 'king';
			// Mark that black's shahsade has been promoted
			shahsadePromoted[1] = true;
			// Change texture to king
			blackShahsade.removeChildAt(0); // Remove old texture
			var kingGraphics = blackShahsade.attachAsset('king', {
				anchorX: 0.5,
				anchorY: 0.5
			});
			if (blackShahsade.pieceColor === 1) {
				kingGraphics.tint = 0x333333;
			}
			// Visual feedback for promotion
			LK.effects.flashObject(blackShahsade, 0xFFD700, 1000); // Flash gold
			// Check if player is in checkmate after promotion
			if (isInCheck(1) && !hasValidMoves(1)) {
				LK.setScore(1);
				LK.showGameOver();
				return;
			}
			// Game continues, don't end
			return;
		} else {
			LK.setScore(1);
			LK.showGameOver();
			return;
		}
	}
	var inCheck = isInCheck(currentPlayer);
	var hasValid = hasValidMoves(currentPlayer);
	// Check for checkmate using new function that respects check privileges
	if (isCheckmate(currentPlayer)) {
		// Checkmate
		LK.setScore(1);
		LK.showGameOver();
	} else if (!hasValid) {
		// 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();
	}
	// Try teleporting pawn of pawns for current player
	tryTeleportPawnOfPawns(currentPlayer);
	var playerText = currentPlayer === 0 ? 'White to move' : 'Black to move';
	if (isInCheck(currentPlayer)) {
		playerText += ' (Check!)';
	}
	turnText.setText(playerText);
};
// List of types the pawn_of_pawns cannot threaten
var EXCLUDED_TYPES = ['camelPawn', 'giraffePawn', 'guardsPawn', 'kingsPawn', 'knightPawn', 'lionsPawn', 'ministersPawn', 'pawnOfTheBull', 'pawnOfTheElephant', 'pawnOfTheLeader', 'pawn', 'pawnOfTheWarMachine', 'viziersPawn', 'king'];
function tryTeleportPawnOfPawns(color) {
	for (var r = 0; r < BOARD_HEIGHT; r++) {
		for (var c = 0; c < BOARD_WIDTH; c++) {
			var p = getPieceAt(r, c);
			if (p && p.pieceType === 'pawnsPawn' && p.pieceColor === color && !p.hasTeleported) {
				for (var tr = 0; tr < BOARD_HEIGHT; tr++) {
					for (var tc = 0; tc < BOARD_WIDTH; tc++) {
						if (getPieceAt(tr, tc)) continue; // Square must be empty
						var threats = countValidThreats(tr, tc, color);
						var blocksImmobilizedEnemy = threatensBlockedEnemy(tr, tc, color);
						if (threats >= 2 || blocksImmobilizedEnemy) {
							// Teleport the pawn of pawns
							p.boardRow = tr;
							p.boardCol = tc;
							p.hasTeleported = true;
							var pos = getBoardPosition(tr, tc);
							tween(p, {
								x: pos.x,
								y: pos.y
							}, {
								duration: 300
							});
							console.log('Pawn of Pawns TELEPORTED to (' + tr + ',' + tc + ')');
							return;
						}
					}
				}
			}
		}
	}
}
function countValidThreats(row, col, color) {
	var count = 0;
	var dirs = [[-1, -1], [-1, 1], [1, -1], [1, 1]]; // Diagonals
	for (var d = 0; d < dirs.length; d++) {
		var dir = dirs[d];
		var r = row + dir[0];
		var c = col + dir[1];
		if (isValidSquare(r, c)) {
			var enemy = getPieceAt(r, c);
			if (enemy && enemy.pieceColor !== color && EXCLUDED_TYPES.indexOf(enemy.pieceType) === -1) {
				// Additional check: pawn of pawns cannot teleport to threaten the king
				if (enemy.pieceType === 'king') {
					return 0; // Prevent teleportation if it would threaten the king
				}
				count++;
			}
		}
	}
	return count;
}
function threatensBlockedEnemy(row, col, color) {
	var dirs = [[-1, -1], [-1, 1], [1, -1], [1, 1]]; // Diagonals
	for (var d = 0; d < dirs.length; d++) {
		var dir = dirs[d];
		var r = row + dir[0];
		var c = col + dir[1];
		if (isValidSquare(r, c)) {
			var enemy = getPieceAt(r, c);
			if (enemy && enemy.pieceColor !== color && EXCLUDED_TYPES.indexOf(enemy.pieceType) === -1) {
				// Additional check: pawn of pawns cannot teleport to threaten the king
				if (enemy.pieceType === 'king') {
					return false; // Prevent teleportation if it would threaten the king
				}
				if (!hasLegalMovesForPiece(enemy, r, c)) {
					return true;
				}
			}
		}
	}
	return false;
}
function hasLegalMovesForPiece(piece, row, col) {
	var moves = piece.getRawMoves();
	for (var i = 0; i < moves.length; i++) {
		if (isValidMoveConsideringCheck(piece, moves[i].row, moves[i].col)) {
			return true;
		}
	}
	return false;
}
function hasImmunityPiece(color) {
	for (var i = 0; i < pieces.length; i++) {
		if (pieces[i].pieceColor === color) {
			if (pieces[i].pieceType === 'adventurousKing' || pieces[i].pieceType === 'shahsade') {
				return true;
			}
		}
	}
	return false;
}
function hasCheckPrivilege(color) {
	return hasAdventurousKing(color) || hasShahsade(color);
}
function isCheckmate(color) {
	if (hasImmunityPiece(color)) {
		console.log(color === 0 ? 'White' : 'Black' + ' has immunity — checkmate ignored.');
		return false;
	}
	return isInCheck(color) && !hasValidMoves(color);
}

===================================================================
--- original.js
+++ change.js
@@ -1437,9 +1437,9 @@
 							});
 						}
 					}
 				}
-				// 2 squares diagonally, horizontally, vertically (same as shahsade)
+				// 2 squares diagonally, horizontally, vertically (adventurous Shah can jump over pieces)
 				var adventurousKingDirections = [{
 					dr: 0,
 					dc: 2
 				}, {
@@ -1468,27 +1468,16 @@
 					var dir = adventurousKingDirections[i];
 					var newRow = self.boardRow + dir.dr;
 					var newCol = self.boardCol + dir.dc;
 					if (isValidSquare(newRow, newCol)) {
-						// Check if path is blocked by any piece
-						var pathBlocked = false;
-						var stepRow = dir.dr === 0 ? 0 : dir.dr > 0 ? 1 : -1;
-						var stepCol = dir.dc === 0 ? 0 : dir.dc > 0 ? 1 : -1;
-						var checkRow = self.boardRow + stepRow;
-						var checkCol = self.boardCol + stepCol;
-						var pathPiece = getPieceAt(checkRow, checkCol);
-						if (pathPiece) {
-							pathBlocked = true;
+						// Adventurous Shah can jump over pieces - no path blocking check
+						var piece = getPieceAt(newRow, newCol);
+						if (!piece || piece.pieceColor !== self.pieceColor) {
+							moves.push({
+								row: newRow,
+								col: newCol
+							});
 						}
-						if (!pathBlocked) {
-							var piece = getPieceAt(newRow, newCol);
-							if (!piece || piece.pieceColor !== self.pieceColor) {
-								moves.push({
-									row: newRow,
-									col: newCol
-								});
-							}
-						}
 					}
 				}
 				break;
 			case 'kingsPawn':