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

/**** 
* Classes
****/ 
var ChessPiece = Container.expand(function (type, color) {
	var self = Container.call(this);
	self.type = type;
	self.color = color;
	self.hasMoved = false;
	var pieceId = color + type.charAt(0).toUpperCase() + type.slice(1);
	var pieceGraphics = self.attachAsset(pieceId, {
		anchorX: 0.5,
		anchorY: 0.5
	});
	var label;
	switch (type) {
		case 'pawn':
			label = '';
			break;
		case 'rook':
			label = 'R';
			break;
		case 'knight':
			label = 'N';
			break;
		case 'bishop':
			label = 'B';
			break;
		case 'queen':
			label = 'Q';
			break;
		case 'king':
			label = 'K';
			break;
	}
	if (label) {
		var text = new Text2(label, {
			size: 40,
			fill: color === 'white' ? "#000000" : "#ffffff"
		});
		text.anchor.set(0.5, 0.5);
		self.addChild(text);
	}
	return self;
});
var ChessSquare = Container.expand(function (row, col, color) {
	var self = Container.call(this);
	self.row = row;
	self.col = col;
	self.color = color;
	self.piece = null;
	var squareGraphics = self.attachAsset(color === 'white' ? 'whiteSquare' : 'blackSquare', {
		anchorX: 0,
		anchorY: 0
	});
	self.highlight = function (type) {
		if (type === 'selected') {
			squareGraphics.tint = 0x829769;
		} else if (type === 'validMove') {
			squareGraphics.tint = 0xcdd26a;
		} else {
			// Reset to original color
			squareGraphics.tint = color === 'white' ? 0xf0d9b5 : 0xb58863;
		}
	};
	self.setPiece = function (piece) {
		if (self.piece) {
			self.removeChild(self.piece);
		}
		self.piece = piece;
		if (piece) {
			self.addChild(piece);
			piece.x = squareGraphics.width / 2;
			piece.y = squareGraphics.height / 2;
		}
	};
	self.down = function (x, y, obj) {
		game.selectSquare(self);
	};
	return self;
});
var CrazyAbility = Container.expand(function () {
	var self = Container.call(this);
	// Available abilities
	self.abilities = [{
		name: 'Freeze',
		description: 'Freezes a white piece for 2 turns'
	}, {
		name: 'Instant Promotion',
		description: 'Promotes a black pawn to a powerful piece'
	}, {
		name: 'Stampede',
		description: 'Removes 3 random pieces from the board'
	}, {
		name: 'Summon',
		description: 'Summons a black rook on an empty square'
	}];
	// Stores pieces that are frozen
	self.frozenPieces = [];
	// Use a random ability
	self.useRandomAbility = function () {
		var randomIndex = Math.floor(Math.random() * self.abilities.length);
		var ability = self.abilities[randomIndex];
		// Show ability notification
		self.showAbilityNotification(ability.name);
		// Execute ability
		switch (ability.name) {
			case 'Freeze':
				self.freezeRandomPiece();
				break;
			case 'Instant Promotion':
				self.instantPromotion();
				break;
			case 'Stampede':
				self.stampede();
				break;
			case 'Summon':
				self.summonRook();
				break;
		}
	};
	// Show notification of ability used
	self.showAbilityNotification = function (abilityName) {
		var notification = new Text2('AI USED: ' + abilityName + '!', {
			size: 50,
			fill: 0xFF0000
		});
		notification.anchor.set(0.5, 0.5);
		notification.x = 2048 / 2;
		notification.y = 2732 / 2 - 300;
		game.addChild(notification);
		// Flash effect
		LK.effects.flashObject(notification, 0xFF0000, 500);
		// Remove after delay
		LK.setTimeout(function () {
			game.removeChild(notification);
		}, 2000);
	};
	// Freeze a random white piece for 2 turns
	self.freezeRandomPiece = function () {
		var whitePieces = [];
		// Find all white pieces
		for (var row = 0; row < BOARD_SIZE; row++) {
			for (var col = 0; col < BOARD_SIZE; col++) {
				var square = board[row][col];
				if (square.piece && square.piece.color === 'white') {
					whitePieces.push({
						square: square,
						row: row,
						col: col
					});
				}
			}
		}
		if (whitePieces.length > 0) {
			// Select random white piece
			var randomIndex = Math.floor(Math.random() * whitePieces.length);
			var targetPiece = whitePieces[randomIndex];
			// Add to frozen list with 2 turns duration
			self.frozenPieces.push({
				row: targetPiece.row,
				col: targetPiece.col,
				turnsLeft: 2
			});
			// Visual effect - tint blue
			targetPiece.square.piece.tint = 0x00AAFF;
		}
	};
	// Turn a random black pawn into a queen, bishop or rook
	self.instantPromotion = function () {
		var blackPawns = [];
		// Find all black pawns
		for (var row = 0; row < BOARD_SIZE; row++) {
			for (var col = 0; col < BOARD_SIZE; col++) {
				var square = board[row][col];
				if (square.piece && square.piece.color === 'black' && square.piece.type === 'pawn') {
					blackPawns.push({
						square: square
					});
				}
			}
		}
		if (blackPawns.length > 0) {
			// Select random black pawn
			var randomIndex = Math.floor(Math.random() * blackPawns.length);
			var targetPawn = blackPawns[randomIndex];
			// Choose random promotion type
			var promotionTypes = ['queen', 'bishop', 'rook'];
			var randomType = promotionTypes[Math.floor(Math.random() * promotionTypes.length)];
			// Promote the pawn
			targetPawn.square.setPiece(new ChessPiece(randomType, 'black'));
			LK.getSound('promotion').play();
		}
	};
	// Remove 3 random pieces from the board
	self.stampede = function () {
		var allPieces = [];
		// Find all pieces
		for (var row = 0; row < BOARD_SIZE; row++) {
			for (var col = 0; col < BOARD_SIZE; col++) {
				var square = board[row][col];
				if (square.piece) {
					allPieces.push({
						square: square
					});
				}
			}
		}
		// Remove up to 3 random pieces
		var removeCount = Math.min(3, allPieces.length);
		for (var i = 0; i < removeCount; i++) {
			if (allPieces.length > 0) {
				var randomIndex = Math.floor(Math.random() * allPieces.length);
				var targetPiece = allPieces[randomIndex];
				// Remove piece
				targetPiece.square.setPiece(null);
				// Remove from array
				allPieces.splice(randomIndex, 1);
			}
		}
		LK.getSound('capture').play();
	};
	// Summon a black rook on a random empty square
	self.summonRook = function () {
		var emptySquares = [];
		// Find all empty squares
		for (var row = 0; row < BOARD_SIZE; row++) {
			for (var col = 0; col < BOARD_SIZE; col++) {
				var square = board[row][col];
				if (!square.piece) {
					emptySquares.push({
						square: square
					});
				}
			}
		}
		if (emptySquares.length > 0) {
			// Select random empty square
			var randomIndex = Math.floor(Math.random() * emptySquares.length);
			var targetSquare = emptySquares[randomIndex];
			// Add new rook
			targetSquare.square.setPiece(new ChessPiece('rook', 'black'));
		}
	};
	// Decrement frozen piece counters
	self.updateFrozenPieces = function () {
		for (var i = self.frozenPieces.length - 1; i >= 0; i--) {
			self.frozenPieces[i].turnsLeft--;
			// If no turns left, unfreeze the piece
			if (self.frozenPieces[i].turnsLeft <= 0) {
				var row = self.frozenPieces[i].row;
				var col = self.frozenPieces[i].col;
				// Only unfreeze if piece still exists at that position
				if (board[row][col].piece && board[row][col].piece.color === 'white') {
					board[row][col].piece.tint = 0xFFFFFF;
				}
				self.frozenPieces.splice(i, 1);
			}
		}
	};
	// Check if a piece is frozen
	self.isPieceFrozen = function (row, col) {
		for (var i = 0; i < self.frozenPieces.length; i++) {
			if (self.frozenPieces[i].row === row && self.frozenPieces[i].col === col) {
				return true;
			}
		}
		return false;
	};
	return self;
});
var GameModeScreen = Container.expand(function () {
	var self = Container.call(this);
	// Create title text
	var titleText = new Text2('Select Game Mode', {
		size: 80,
		fill: 0xFFFFFF
	});
	titleText.anchor.set(0.5, 0.5);
	titleText.y = -250;
	self.addChild(titleText);
	// Create mode buttons
	var classicButton = new Text2('CLASSIC', {
		size: 60,
		fill: 0xFFFFFF
	});
	classicButton.anchor.set(0.5, 0.5);
	classicButton.y = -50;
	self.addChild(classicButton);
	var crazyButton = new Text2('CRAZY MODE', {
		size: 60,
		fill: 0xFFFFFF
	});
	crazyButton.anchor.set(0.5, 0.5);
	crazyButton.y = 50;
	self.addChild(crazyButton);
	var tournamentButton = new Text2('TOURNAMENT', {
		size: 60,
		fill: 0xFFFFFF
	});
	tournamentButton.anchor.set(0.5, 0.5);
	tournamentButton.y = 150;
	self.addChild(tournamentButton);
	var backButton = new Text2('< BACK', {
		size: 40,
		fill: 0xFFFFFF
	});
	backButton.anchor.set(0.5, 0.5);
	backButton.y = 300;
	self.addChild(backButton);
	// Add highlighting for buttons
	var buttons = [classicButton, crazyButton, tournamentButton, backButton];
	var buttonBackgrounds = [];
	// Create button backgrounds
	for (var i = 0; i < buttons.length; i++) {
		var btn = buttons[i];
		var bg = LK.getAsset('blackSquare', {
			anchorX: 0.5,
			anchorY: 0.5,
			width: btn.width + 40,
			height: btn.height + 20,
			tint: 0x3a3a3a
		});
		bg.alpha = 0.7;
		bg.x = btn.x;
		bg.y = btn.y;
		buttonBackgrounds.push(bg);
		self.addChild(bg);
		self.addChild(btn); // Re-add button to put it on top
	}
	// Add button hover effects
	for (var i = 0; i < buttons.length; i++) {
		(function (index) {
			var btn = buttons[index];
			var bg = buttonBackgrounds[index];
			btn.interactive = true;
			btn.down = function (x, y, obj) {
				// Flash button when clicked
				tween(bg, {
					alpha: 1
				}, {
					duration: 100,
					onFinish: function onComplete() {
						tween(bg, {
							alpha: 0.7
						}, {
							duration: 100
						});
					}
				});
				// Handle button action
				if (index === 0) {
					// Classic mode
					game.gameMode = 'classic';
					game.startGame();
				} else if (index === 1) {
					// Crazy mode
					game.gameMode = 'crazy';
					game.startGame();
				} else if (index === 2) {
					// Tournament mode
					game.gameMode = 'tournament';
					game.startGame();
				} else if (index === 3) {
					// Back button
					game.showTitleScreen();
				}
			};
		})(i);
	}
	// Pulse animation for the first button
	var pulseScale = 1;
	var increasing = true;
	self.update = function () {
		// Pulse effect for the Classic button
		if (increasing) {
			pulseScale += 0.002;
			if (pulseScale >= 1.05) {
				increasing = false;
			}
		} else {
			pulseScale -= 0.002;
			if (pulseScale <= 0.95) {
				increasing = true;
			}
		}
		classicButton.scale.set(pulseScale);
		buttonBackgrounds[0].scale.set(pulseScale);
	};
	return self;
});
var TitleScreen = Container.expand(function () {
	var self = Container.call(this);
	// Create title text
	var titleText = new Text2('Crazy Chess', {
		size: 120,
		fill: 0xFFFFFF
	});
	titleText.anchor.set(0.5, 0.5);
	self.addChild(titleText);
	// Create start button
	var startButton = new Text2('TAP TO START', {
		size: 60,
		fill: 0xFFFFFF
	});
	startButton.anchor.set(0.5, 0.5);
	startButton.y = 200;
	self.addChild(startButton);
	// Add pulsing animation to the start button
	var pulseScale = 1;
	var increasing = true;
	self.update = function () {
		// Pulse effect for start button
		if (increasing) {
			pulseScale += 0.003;
			if (pulseScale >= 1.1) {
				increasing = false;
			}
		} else {
			pulseScale -= 0.003;
			if (pulseScale <= 0.9) {
				increasing = true;
			}
		}
		startButton.scale.set(pulseScale);
	};
	// Handle tap anywhere to start
	self.down = function () {
		game.showGameModeScreen();
	};
	return self;
});

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

/**** 
* Game Code
****/ 
// Game constants
var BOARD_SIZE = 8;
var SQUARE_SIZE = 100;
var BOARD_OFFSET_X = (2048 - BOARD_SIZE * SQUARE_SIZE) / 2;
var BOARD_OFFSET_Y = (2732 - BOARD_SIZE * SQUARE_SIZE) / 2;
// Game state variables
var board = [];
var selectedSquare = null;
var validMoves = [];
var currentPlayer = 'white';
var gameState = 'title'; // 'title', 'modeSelect', 'playing', 'check', 'checkmate', 'stalemate'
var aiThinking = false;
var titleScreen = null;
var gameModeScreen = null;
var gameMode = 'classic'; // 'classic', 'crazy', 'tournament'
var crazyAbilities = new CrazyAbility();
var crazyAbilityChance = 0.4; // 40% chance of AI using ability after a move
// Initialize the chess board
function initializeBoard() {
	board = [];
	// Create the 8x8 chess board
	for (var row = 0; row < BOARD_SIZE; row++) {
		board[row] = [];
		for (var col = 0; col < BOARD_SIZE; col++) {
			var squareColor = (row + col) % 2 === 0 ? 'white' : 'black';
			var square = new ChessSquare(row, col, squareColor);
			square.x = BOARD_OFFSET_X + col * SQUARE_SIZE;
			square.y = BOARD_OFFSET_Y + row * SQUARE_SIZE;
			board[row][col] = square;
			game.addChild(square);
		}
	}
	// Place the pieces on the board
	placePieces();
}
// Place all chess pieces in their starting positions
function placePieces() {
	// Place pawns
	for (var col = 0; col < BOARD_SIZE; col++) {
		board[1][col].setPiece(new ChessPiece('pawn', 'black'));
		board[6][col].setPiece(new ChessPiece('pawn', 'white'));
	}
	// Place rooks
	board[0][0].setPiece(new ChessPiece('rook', 'black'));
	board[0][7].setPiece(new ChessPiece('rook', 'black'));
	board[7][0].setPiece(new ChessPiece('rook', 'white'));
	board[7][7].setPiece(new ChessPiece('rook', 'white'));
	// Place knights
	board[0][1].setPiece(new ChessPiece('knight', 'black'));
	board[0][6].setPiece(new ChessPiece('knight', 'black'));
	board[7][1].setPiece(new ChessPiece('knight', 'white'));
	board[7][6].setPiece(new ChessPiece('knight', 'white'));
	// Place bishops
	board[0][2].setPiece(new ChessPiece('bishop', 'black'));
	board[0][5].setPiece(new ChessPiece('bishop', 'black'));
	board[7][2].setPiece(new ChessPiece('bishop', 'white'));
	board[7][5].setPiece(new ChessPiece('bishop', 'white'));
	// Place queens
	board[0][3].setPiece(new ChessPiece('queen', 'black'));
	board[7][3].setPiece(new ChessPiece('queen', 'white'));
	// Place kings
	board[0][4].setPiece(new ChessPiece('king', 'black'));
	board[7][4].setPiece(new ChessPiece('king', 'white'));
}
// Select a square on the chess board
game.selectSquare = function (square) {
	// If AI is thinking, don't allow moves
	if (aiThinking || gameState === 'checkmate' || gameState === 'stalemate') {
		return;
	}
	// If the current player is not the human player, don't allow moves
	if (currentPlayer !== 'white') {
		return;
	}
	// Check if piece is frozen (Crazy Mode)
	if (gameMode === 'crazy' && square.piece && square.piece.color === 'white' && crazyAbilities.isPieceFrozen(square.row, square.col)) {
		// Show notification that piece is frozen
		var notification = new Text2('This piece is frozen!', {
			size: 40,
			fill: 0x00AAFF
		});
		notification.anchor.set(0.5, 0.5);
		notification.x = 2048 / 2;
		notification.y = 2732 / 2 - 200;
		game.addChild(notification);
		// Remove notification after delay
		LK.setTimeout(function () {
			game.removeChild(notification);
		}, 1500);
		return;
	}
	// Clear previous selections
	clearHighlights();
	// If a square is already selected and the new square is a valid move
	if (selectedSquare && isValidMove(square)) {
		// Move the piece
		movePiece(selectedSquare, square);
		// Reset selection
		selectedSquare = null;
		validMoves = [];
		// Check for check/checkmate
		checkGameState();
		// If game is still playing, switch to AI turn
		if (gameState === 'playing' || gameState === 'check') {
			switchPlayer();
			// Start AI turn
			aiThinking = true;
			LK.setTimeout(makeAIMove, 1000);
		}
	}
	// If clicking on a piece of the current player
	else if (square.piece && square.piece.color === currentPlayer) {
		// Select the square
		selectedSquare = square;
		square.highlight('selected');
		// Calculate valid moves
		validMoves = calculateValidMoves(square);
		// Highlight valid moves
		for (var i = 0; i < validMoves.length; i++) {
			var move = validMoves[i];
			board[move.row][move.col].highlight('validMove');
		}
	}
};
// Check if a move to the target square is valid
function isValidMove(targetSquare) {
	for (var i = 0; i < validMoves.length; i++) {
		var move = validMoves[i];
		if (move.row === targetSquare.row && move.col === targetSquare.col) {
			return true;
		}
	}
	return false;
}
// Move a piece from one square to another
function movePiece(fromSquare, toSquare) {
	var piece = fromSquare.piece;
	// Handle capture
	if (toSquare.piece) {
		LK.getSound('capture').play();
	} else {
		LK.getSound('move').play();
	}
	// Move the piece
	fromSquare.setPiece(null);
	toSquare.setPiece(piece);
	// Mark piece as moved (for castling and pawn double move)
	piece.hasMoved = true;
	// Handle pawn promotion
	if (piece.type === 'pawn' && (toSquare.row === 0 || toSquare.row === 7)) {
		promotePawn(toSquare);
	}
}
// Promote a pawn to a queen
function promotePawn(square) {
	var piece = square.piece;
	square.setPiece(new ChessPiece('queen', piece.color));
	LK.getSound('promotion').play();
}
// Clear highlights from all squares
function clearHighlights() {
	for (var row = 0; row < BOARD_SIZE; row++) {
		for (var col = 0; col < BOARD_SIZE; col++) {
			board[row][col].highlight();
		}
	}
}
// Calculate valid moves for a piece
function calculateValidMoves(square) {
	var piece = square.piece;
	var moves = [];
	if (!piece) {
		return moves;
	}
	var row = square.row;
	var col = square.col;
	switch (piece.type) {
		case 'pawn':
			calculatePawnMoves(row, col, piece, moves);
			break;
		case 'rook':
			calculateRookMoves(row, col, piece, moves);
			break;
		case 'knight':
			calculateKnightMoves(row, col, piece, moves);
			break;
		case 'bishop':
			calculateBishopMoves(row, col, piece, moves);
			break;
		case 'queen':
			calculateRookMoves(row, col, piece, moves);
			calculateBishopMoves(row, col, piece, moves);
			break;
		case 'king':
			calculateKingMoves(row, col, piece, moves);
			break;
	}
	// Filter out moves that would put the king in check
	return filterCheckMoves(square, moves);
}
// Calculate valid moves for a pawn
function calculatePawnMoves(row, col, piece, moves) {
	var direction = piece.color === 'white' ? -1 : 1;
	// Move forward one square
	if (isValidSquare(row + direction, col) && !board[row + direction][col].piece) {
		moves.push({
			row: row + direction,
			col: col
		});
		// Move forward two squares from starting position
		if (!piece.hasMoved && isValidSquare(row + 2 * direction, col) && !board[row + 2 * direction][col].piece) {
			moves.push({
				row: row + 2 * direction,
				col: col
			});
		}
	}
	// Captures
	var captureDirections = [{
		row: direction,
		col: -1
	}, {
		row: direction,
		col: 1
	}];
	for (var i = 0; i < captureDirections.length; i++) {
		var dir = captureDirections[i];
		var newRow = row + dir.row;
		var newCol = col + dir.col;
		if (isValidSquare(newRow, newCol) && board[newRow][newCol].piece && board[newRow][newCol].piece.color !== piece.color) {
			moves.push({
				row: newRow,
				col: newCol
			});
		}
	}
}
// Calculate valid moves for a rook
function calculateRookMoves(row, col, piece, moves) {
	var directions = [{
		row: -1,
		col: 0
	},
	// up
	{
		row: 1,
		col: 0
	},
	// down
	{
		row: 0,
		col: -1
	},
	// left
	{
		row: 0,
		col: 1
	} // right
	];
	calculateSlidingMoves(row, col, piece, moves, directions);
}
// Calculate valid moves for a bishop
function calculateBishopMoves(row, col, piece, moves) {
	var directions = [{
		row: -1,
		col: -1
	},
	// up-left
	{
		row: -1,
		col: 1
	},
	// up-right
	{
		row: 1,
		col: -1
	},
	// down-left
	{
		row: 1,
		col: 1
	} // down-right
	];
	calculateSlidingMoves(row, col, piece, moves, directions);
}
// Calculate valid moves for sliding pieces (rook, bishop, queen)
function calculateSlidingMoves(row, col, piece, moves, directions) {
	for (var i = 0; i < directions.length; i++) {
		var dir = directions[i];
		var newRow = row + dir.row;
		var newCol = col + dir.col;
		while (isValidSquare(newRow, newCol)) {
			var targetSquare = board[newRow][newCol];
			if (!targetSquare.piece) {
				// Empty square, can move here
				moves.push({
					row: newRow,
					col: newCol
				});
			} else {
				// Found a piece
				if (targetSquare.piece.color !== piece.color) {
					// Can capture opponent's piece
					moves.push({
						row: newRow,
						col: newCol
					});
				}
				// Can't move past a piece
				break;
			}
			newRow += dir.row;
			newCol += dir.col;
		}
	}
}
// Calculate valid moves for a knight
function calculateKnightMoves(row, col, piece, moves) {
	var knightDirections = [{
		row: -2,
		col: -1
	}, {
		row: -2,
		col: 1
	}, {
		row: -1,
		col: -2
	}, {
		row: -1,
		col: 2
	}, {
		row: 1,
		col: -2
	}, {
		row: 1,
		col: 2
	}, {
		row: 2,
		col: -1
	}, {
		row: 2,
		col: 1
	}];
	for (var i = 0; i < knightDirections.length; i++) {
		var dir = knightDirections[i];
		var newRow = row + dir.row;
		var newCol = col + dir.col;
		if (isValidSquare(newRow, newCol)) {
			var targetSquare = board[newRow][newCol];
			if (!targetSquare.piece || targetSquare.piece.color !== piece.color) {
				moves.push({
					row: newRow,
					col: newCol
				});
			}
		}
	}
}
// Calculate valid moves for a king
function calculateKingMoves(row, col, piece, moves) {
	var kingDirections = [{
		row: -1,
		col: -1
	}, {
		row: -1,
		col: 0
	}, {
		row: -1,
		col: 1
	}, {
		row: 0,
		col: -1
	}, {
		row: 0,
		col: 1
	}, {
		row: 1,
		col: -1
	}, {
		row: 1,
		col: 0
	}, {
		row: 1,
		col: 1
	}];
	for (var i = 0; i < kingDirections.length; i++) {
		var dir = kingDirections[i];
		var newRow = row + dir.row;
		var newCol = col + dir.col;
		if (isValidSquare(newRow, newCol)) {
			var targetSquare = board[newRow][newCol];
			if (!targetSquare.piece || targetSquare.piece.color !== piece.color) {
				moves.push({
					row: newRow,
					col: newCol
				});
			}
		}
	}
	// Castling
	if (!piece.hasMoved) {
		// Kingside castling
		if (canCastle(row, col, 0, 3)) {
			moves.push({
				row: row,
				col: col + 2
			});
		}
		// Queenside castling
		if (canCastle(row, col, 0, -4)) {
			moves.push({
				row: row,
				col: col - 2
			});
		}
	}
}
// Check if castling is possible
function canCastle(row, col, rowOffset, colOffset) {
	var rookCol = colOffset > 0 ? 7 : 0;
	var rookRow = row;
	// Check if there's a rook in the corner
	var rookSquare = board[rookRow][rookCol];
	if (!rookSquare.piece || rookSquare.piece.type !== 'rook' || rookSquare.piece.hasMoved) {
		return false;
	}
	// Check if there are pieces between the king and the rook
	var startCol = Math.min(col, rookCol) + 1;
	var endCol = Math.max(col, rookCol) - 1;
	for (var c = startCol; c <= endCol; c++) {
		if (board[row][c].piece) {
			return false;
		}
	}
	// Check if the king would move through or into check
	var direction = colOffset > 0 ? 1 : -1;
	if (isSquareAttacked(row, col, otherPlayer(currentPlayer)) || isSquareAttacked(row, col + direction, otherPlayer(currentPlayer)) || isSquareAttacked(row, col + 2 * direction, otherPlayer(currentPlayer))) {
		return false;
	}
	return true;
}
// Filter out moves that would put the king in check
function filterCheckMoves(fromSquare, moves) {
	var validMoves = [];
	var piece = fromSquare.piece;
	for (var i = 0; i < moves.length; i++) {
		var move = moves[i];
		// Simulate the move
		var originalPiece = board[move.row][move.col].piece;
		board[move.row][move.col].piece = piece;
		board[fromSquare.row][fromSquare.col].piece = null;
		// Check if the king is in check after the move
		var inCheck = isKingInCheck(piece.color);
		// Undo the move
		board[fromSquare.row][fromSquare.col].piece = piece;
		board[move.row][move.col].piece = originalPiece;
		if (!inCheck) {
			validMoves.push(move);
		}
	}
	return validMoves;
}
// Check if a square is valid (within the board)
function isValidSquare(row, col) {
	return row >= 0 && row < BOARD_SIZE && col >= 0 && col < BOARD_SIZE;
}
// Check if the king is in check
function isKingInCheck(color) {
	// Find the king
	var kingSquare = findKing(color);
	if (!kingSquare) {
		return false;
	}
	// Check if the king is attacked by any opponent's piece
	return isSquareAttacked(kingSquare.row, kingSquare.col, otherPlayer(color));
}
// Check if a square is attacked by any piece of the given color
function isSquareAttacked(row, col, attackerColor) {
	for (var r = 0; r < BOARD_SIZE; r++) {
		for (var c = 0; c < BOARD_SIZE; c++) {
			var square = board[r][c];
			if (square.piece && square.piece.color === attackerColor) {
				var moves = [];
				switch (square.piece.type) {
					case 'pawn':
						// Pawns attack diagonally
						var direction = square.piece.color === 'white' ? -1 : 1;
						var attackDirections = [{
							row: direction,
							col: -1
						}, {
							row: direction,
							col: 1
						}];
						for (var i = 0; i < attackDirections.length; i++) {
							var dir = attackDirections[i];
							var attackRow = r + dir.row;
							var attackCol = c + dir.col;
							if (attackRow === row && attackCol === col) {
								return true;
							}
						}
						break;
					case 'rook':
						calculateRookMoves(r, c, square.piece, moves);
						break;
					case 'knight':
						calculateKnightMoves(r, c, square.piece, moves);
						break;
					case 'bishop':
						calculateBishopMoves(r, c, square.piece, moves);
						break;
					case 'queen':
						calculateRookMoves(r, c, square.piece, moves);
						calculateBishopMoves(r, c, square.piece, moves);
						break;
					case 'king':
						var kingDirections = [{
							row: -1,
							col: -1
						}, {
							row: -1,
							col: 0
						}, {
							row: -1,
							col: 1
						}, {
							row: 0,
							col: -1
						}, {
							row: 0,
							col: 1
						}, {
							row: 1,
							col: -1
						}, {
							row: 1,
							col: 0
						}, {
							row: 1,
							col: 1
						}];
						for (var i = 0; i < kingDirections.length; i++) {
							var dir = kingDirections[i];
							var attackRow = r + dir.row;
							var attackCol = c + dir.col;
							if (attackRow === row && attackCol === col) {
								return true;
							}
						}
						break;
				}
				// Check if the square is in the list of moves
				for (var i = 0; i < moves.length; i++) {
					var move = moves[i];
					if (move.row === row && move.col === col) {
						return true;
					}
				}
			}
		}
	}
	return false;
}
// Find the king of the given color
function findKing(color) {
	for (var row = 0; row < BOARD_SIZE; row++) {
		for (var col = 0; col < BOARD_SIZE; col++) {
			var square = board[row][col];
			if (square.piece && square.piece.type === 'king' && square.piece.color === color) {
				return {
					row: row,
					col: col
				};
			}
		}
	}
	return null;
}
// Get the other player's color
function otherPlayer(color) {
	return color === 'white' ? 'black' : 'white';
}
// Switch the current player
function switchPlayer() {
	currentPlayer = otherPlayer(currentPlayer);
}
// Check the game state (check, checkmate, stalemate)
function checkGameState() {
	// Check if the current player's king is in check
	var inCheck = isKingInCheck(currentPlayer);
	// Get all possible moves for the current player
	var allMoves = getAllPossibleMoves(currentPlayer);
	if (inCheck) {
		if (allMoves.length === 0) {
			// Checkmate
			gameState = 'checkmate';
			endGame(otherPlayer(currentPlayer) + ' wins by checkmate!');
		} else {
			// Check
			gameState = 'check';
			LK.getSound('check').play();
		}
	} else if (allMoves.length === 0) {
		// Stalemate
		gameState = 'stalemate';
		endGame('Draw by stalemate!');
	} else {
		gameState = 'playing';
	}
}
// Get all possible moves for a player
function getAllPossibleMoves(color) {
	var allMoves = [];
	for (var row = 0; row < BOARD_SIZE; row++) {
		for (var col = 0; col < BOARD_SIZE; col++) {
			var square = board[row][col];
			if (square.piece && square.piece.color === color) {
				var moves = calculateValidMoves(square);
				for (var i = 0; i < moves.length; i++) {
					allMoves.push({
						fromRow: row,
						fromCol: col,
						toRow: moves[i].row,
						toCol: moves[i].col
					});
				}
			}
		}
	}
	return allMoves;
}
// End the game
function endGame(message) {
	var gameOverText = new Text2(message, {
		size: 60,
		fill: 0xFFFFFF
	});
	gameOverText.anchor.set(0.5, 0.5);
	gameOverText.x = 2048 / 2;
	gameOverText.y = 200;
	game.addChild(gameOverText);
	// Update score based on winner
	if (gameState === 'checkmate') {
		if (currentPlayer === 'black') {
			// White wins
			LK.setScore(100);
		} else {
			// Black wins (AI wins)
			LK.setScore(0);
		}
	} else {
		// Draw
		LK.setScore(50);
	}
	// Show game over after a short delay
	LK.setTimeout(function () {
		LK.showGameOver();
	}, 3000);
}
// Make an AI move
function makeAIMove() {
	if (gameState === 'checkmate' || gameState === 'stalemate') {
		aiThinking = false;
		return;
	}
	// Get all possible moves for the AI
	var possibleMoves = getAllPossibleMoves('black');
	if (possibleMoves.length === 0) {
		aiThinking = false;
		return;
	}
	// Simple AI: pick a random move
	var randomMove = possibleMoves[Math.floor(Math.random() * possibleMoves.length)];
	// Make the move
	var fromSquare = board[randomMove.fromRow][randomMove.fromCol];
	var toSquare = board[randomMove.toRow][randomMove.toCol];
	// Highlight the selected square
	fromSquare.highlight('selected');
	// Wait a bit before making the move
	LK.setTimeout(function () {
		// Move the piece
		movePiece(fromSquare, toSquare);
		// Clear highlights
		clearHighlights();
		// Use crazy ability in crazy mode
		if (gameMode === 'crazy' && Math.random() < crazyAbilityChance) {
			// Use ability after a short delay
			LK.setTimeout(function () {
				crazyAbilities.useRandomAbility();
			}, 500);
		}
		// Check for check/checkmate
		checkGameState();
		// Switch back to player
		switchPlayer();
		// Update frozen pieces in crazy mode
		if (gameMode === 'crazy') {
			crazyAbilities.updateFrozenPieces();
		}
		// AI turn is over
		aiThinking = false;
	}, 500);
}
// Create score display
var scoreTxt = new Text2('Crazy Chess', {
	size: 60,
	fill: 0xFFFFFF
});
scoreTxt.anchor.set(0.5, 0);
LK.gui.top.addChild(scoreTxt);
// Create turn display
var turnText = new Text2('Your Turn', {
	size: 40,
	fill: 0xFFFFFF
});
turnText.anchor.set(0.5, 0);
turnText.y = 70;
LK.gui.top.addChild(turnText);
// Game update function
game.update = function () {
	// If in title screen, update title screen
	if (gameState === 'title' && titleScreen) {
		titleScreen.update();
		return;
	}
	// If in game mode selection screen, update that screen
	if (gameState === 'modeSelect' && gameModeScreen) {
		gameModeScreen.update();
		return;
	}
	// Update turn text
	if (gameState === 'checkmate') {
		if (currentPlayer === 'black') {
			turnText.setText('You Win!');
		} else {
			turnText.setText('AI Wins!');
		}
	} else if (gameState === 'stalemate') {
		turnText.setText('Draw!');
	} else if (aiThinking) {
		turnText.setText('AI Thinking...');
	} else {
		turnText.setText(currentPlayer === 'white' ? 'Your Turn' : 'AI Turn');
	}
};
// Method to show the game mode selection screen
game.showGameModeScreen = function () {
	// Remove title screen if it exists
	if (titleScreen) {
		game.removeChild(titleScreen);
		titleScreen = null;
	}
	// Remove game mode screen if it already exists
	if (gameModeScreen) {
		game.removeChild(gameModeScreen);
	}
	// Create and add game mode screen
	gameModeScreen = new GameModeScreen();
	gameModeScreen.x = 2048 / 2;
	gameModeScreen.y = 2732 / 2;
	game.addChild(gameModeScreen);
	// Update game state
	gameState = 'modeSelect';
};
// Method to show the title screen
game.showTitleScreen = function () {
	// Remove game mode screen if it exists
	if (gameModeScreen) {
		game.removeChild(gameModeScreen);
		gameModeScreen = null;
	}
	// Create and add title screen
	titleScreen = new TitleScreen();
	titleScreen.x = 2048 / 2;
	titleScreen.y = 2732 / 2;
	game.addChild(titleScreen);
	// Update game state
	gameState = 'title';
};
// Method to start the game from mode selection screen
game.startGame = function () {
	// Remove game mode screen if it exists
	if (gameModeScreen) {
		game.removeChild(gameModeScreen);
		gameModeScreen = null;
	}
	// Change state to playing
	gameState = 'playing';
	// Update game title based on selected mode
	scoreTxt.setText('Crazy Chess - ' + gameMode.toUpperCase());
	// Initialize the chess board
	initializeBoard();
	// Show the score and turn text
	scoreTxt.visible = true;
	turnText.visible = true;
};
// Show title screen first
titleScreen = new TitleScreen();
titleScreen.x = 2048 / 2;
titleScreen.y = 2732 / 2;
game.addChild(titleScreen);
// Hide score and turn text initially
scoreTxt.visible = false;
turnText.visible = false;
;

===================================================================
--- original.js
+++ change.js
@@ -83,8 +83,198 @@
 		game.selectSquare(self);
 	};
 	return self;
 });
+var CrazyAbility = Container.expand(function () {
+	var self = Container.call(this);
+	// Available abilities
+	self.abilities = [{
+		name: 'Freeze',
+		description: 'Freezes a white piece for 2 turns'
+	}, {
+		name: 'Instant Promotion',
+		description: 'Promotes a black pawn to a powerful piece'
+	}, {
+		name: 'Stampede',
+		description: 'Removes 3 random pieces from the board'
+	}, {
+		name: 'Summon',
+		description: 'Summons a black rook on an empty square'
+	}];
+	// Stores pieces that are frozen
+	self.frozenPieces = [];
+	// Use a random ability
+	self.useRandomAbility = function () {
+		var randomIndex = Math.floor(Math.random() * self.abilities.length);
+		var ability = self.abilities[randomIndex];
+		// Show ability notification
+		self.showAbilityNotification(ability.name);
+		// Execute ability
+		switch (ability.name) {
+			case 'Freeze':
+				self.freezeRandomPiece();
+				break;
+			case 'Instant Promotion':
+				self.instantPromotion();
+				break;
+			case 'Stampede':
+				self.stampede();
+				break;
+			case 'Summon':
+				self.summonRook();
+				break;
+		}
+	};
+	// Show notification of ability used
+	self.showAbilityNotification = function (abilityName) {
+		var notification = new Text2('AI USED: ' + abilityName + '!', {
+			size: 50,
+			fill: 0xFF0000
+		});
+		notification.anchor.set(0.5, 0.5);
+		notification.x = 2048 / 2;
+		notification.y = 2732 / 2 - 300;
+		game.addChild(notification);
+		// Flash effect
+		LK.effects.flashObject(notification, 0xFF0000, 500);
+		// Remove after delay
+		LK.setTimeout(function () {
+			game.removeChild(notification);
+		}, 2000);
+	};
+	// Freeze a random white piece for 2 turns
+	self.freezeRandomPiece = function () {
+		var whitePieces = [];
+		// Find all white pieces
+		for (var row = 0; row < BOARD_SIZE; row++) {
+			for (var col = 0; col < BOARD_SIZE; col++) {
+				var square = board[row][col];
+				if (square.piece && square.piece.color === 'white') {
+					whitePieces.push({
+						square: square,
+						row: row,
+						col: col
+					});
+				}
+			}
+		}
+		if (whitePieces.length > 0) {
+			// Select random white piece
+			var randomIndex = Math.floor(Math.random() * whitePieces.length);
+			var targetPiece = whitePieces[randomIndex];
+			// Add to frozen list with 2 turns duration
+			self.frozenPieces.push({
+				row: targetPiece.row,
+				col: targetPiece.col,
+				turnsLeft: 2
+			});
+			// Visual effect - tint blue
+			targetPiece.square.piece.tint = 0x00AAFF;
+		}
+	};
+	// Turn a random black pawn into a queen, bishop or rook
+	self.instantPromotion = function () {
+		var blackPawns = [];
+		// Find all black pawns
+		for (var row = 0; row < BOARD_SIZE; row++) {
+			for (var col = 0; col < BOARD_SIZE; col++) {
+				var square = board[row][col];
+				if (square.piece && square.piece.color === 'black' && square.piece.type === 'pawn') {
+					blackPawns.push({
+						square: square
+					});
+				}
+			}
+		}
+		if (blackPawns.length > 0) {
+			// Select random black pawn
+			var randomIndex = Math.floor(Math.random() * blackPawns.length);
+			var targetPawn = blackPawns[randomIndex];
+			// Choose random promotion type
+			var promotionTypes = ['queen', 'bishop', 'rook'];
+			var randomType = promotionTypes[Math.floor(Math.random() * promotionTypes.length)];
+			// Promote the pawn
+			targetPawn.square.setPiece(new ChessPiece(randomType, 'black'));
+			LK.getSound('promotion').play();
+		}
+	};
+	// Remove 3 random pieces from the board
+	self.stampede = function () {
+		var allPieces = [];
+		// Find all pieces
+		for (var row = 0; row < BOARD_SIZE; row++) {
+			for (var col = 0; col < BOARD_SIZE; col++) {
+				var square = board[row][col];
+				if (square.piece) {
+					allPieces.push({
+						square: square
+					});
+				}
+			}
+		}
+		// Remove up to 3 random pieces
+		var removeCount = Math.min(3, allPieces.length);
+		for (var i = 0; i < removeCount; i++) {
+			if (allPieces.length > 0) {
+				var randomIndex = Math.floor(Math.random() * allPieces.length);
+				var targetPiece = allPieces[randomIndex];
+				// Remove piece
+				targetPiece.square.setPiece(null);
+				// Remove from array
+				allPieces.splice(randomIndex, 1);
+			}
+		}
+		LK.getSound('capture').play();
+	};
+	// Summon a black rook on a random empty square
+	self.summonRook = function () {
+		var emptySquares = [];
+		// Find all empty squares
+		for (var row = 0; row < BOARD_SIZE; row++) {
+			for (var col = 0; col < BOARD_SIZE; col++) {
+				var square = board[row][col];
+				if (!square.piece) {
+					emptySquares.push({
+						square: square
+					});
+				}
+			}
+		}
+		if (emptySquares.length > 0) {
+			// Select random empty square
+			var randomIndex = Math.floor(Math.random() * emptySquares.length);
+			var targetSquare = emptySquares[randomIndex];
+			// Add new rook
+			targetSquare.square.setPiece(new ChessPiece('rook', 'black'));
+		}
+	};
+	// Decrement frozen piece counters
+	self.updateFrozenPieces = function () {
+		for (var i = self.frozenPieces.length - 1; i >= 0; i--) {
+			self.frozenPieces[i].turnsLeft--;
+			// If no turns left, unfreeze the piece
+			if (self.frozenPieces[i].turnsLeft <= 0) {
+				var row = self.frozenPieces[i].row;
+				var col = self.frozenPieces[i].col;
+				// Only unfreeze if piece still exists at that position
+				if (board[row][col].piece && board[row][col].piece.color === 'white') {
+					board[row][col].piece.tint = 0xFFFFFF;
+				}
+				self.frozenPieces.splice(i, 1);
+			}
+		}
+	};
+	// Check if a piece is frozen
+	self.isPieceFrozen = function (row, col) {
+		for (var i = 0; i < self.frozenPieces.length; i++) {
+			if (self.frozenPieces[i].row === row && self.frozenPieces[i].col === col) {
+				return true;
+			}
+		}
+		return false;
+	};
+	return self;
+});
 var GameModeScreen = Container.expand(function () {
 	var self = Container.call(this);
 	// Create title text
 	var titleText = new Text2('Select Game Mode', {
@@ -270,8 +460,10 @@
 var aiThinking = false;
 var titleScreen = null;
 var gameModeScreen = null;
 var gameMode = 'classic'; // 'classic', 'crazy', 'tournament'
+var crazyAbilities = new CrazyAbility();
+var crazyAbilityChance = 0.4; // 40% chance of AI using ability after a move
 // Initialize the chess board
 function initializeBoard() {
 	board = [];
 	// Create the 8x8 chess board
@@ -327,8 +519,25 @@
 	// If the current player is not the human player, don't allow moves
 	if (currentPlayer !== 'white') {
 		return;
 	}
+	// Check if piece is frozen (Crazy Mode)
+	if (gameMode === 'crazy' && square.piece && square.piece.color === 'white' && crazyAbilities.isPieceFrozen(square.row, square.col)) {
+		// Show notification that piece is frozen
+		var notification = new Text2('This piece is frozen!', {
+			size: 40,
+			fill: 0x00AAFF
+		});
+		notification.anchor.set(0.5, 0.5);
+		notification.x = 2048 / 2;
+		notification.y = 2732 / 2 - 200;
+		game.addChild(notification);
+		// Remove notification after delay
+		LK.setTimeout(function () {
+			game.removeChild(notification);
+		}, 1500);
+		return;
+	}
 	// Clear previous selections
 	clearHighlights();
 	// If a square is already selected and the new square is a valid move
 	if (selectedSquare && isValidMove(square)) {
@@ -389,45 +598,13 @@
 	if (piece.type === 'pawn' && (toSquare.row === 0 || toSquare.row === 7)) {
 		promotePawn(toSquare);
 	}
 }
-// Promote a pawn to a queen or random piece in crazy mode
+// Promote a pawn to a queen
 function promotePawn(square) {
 	var piece = square.piece;
-	if (gameMode === 'crazy' && piece.color === 'black') {
-		// In crazy mode, AI gets random promotions
-		var randomPiece = Math.random();
-		var pieceType;
-		if (randomPiece < 0.3) {
-			pieceType = 'queen';
-		} else if (randomPiece < 0.6) {
-			pieceType = 'rook';
-		} else if (randomPiece < 0.8) {
-			pieceType = 'knight';
-		} else {
-			pieceType = 'bishop';
-		}
-		square.setPiece(new ChessPiece(pieceType, piece.color));
-	} else {
-		// Default promotion to queen
-		square.setPiece(new ChessPiece('queen', piece.color));
-	}
+	square.setPiece(new ChessPiece('queen', piece.color));
 	LK.getSound('promotion').play();
-	// Show effect for crazy mode AI promotion
-	if (gameMode === 'crazy' && piece.color === 'black') {
-		LK.effects.flashObject(square, 0xFF00FF, 500);
-		var effectText = new Text2("CRAZY PROMOTION!", {
-			size: 40,
-			fill: 0xFF00FF
-		});
-		effectText.anchor.set(0.5, 0.5);
-		effectText.x = square.x + SQUARE_SIZE / 2;
-		effectText.y = square.y - 30;
-		game.addChild(effectText);
-		LK.setTimeout(function () {
-			game.removeChild(effectText);
-		}, 1500);
-	}
 }
 // Clear highlights from all squares
 function clearHighlights() {
 	for (var row = 0; row < BOARD_SIZE; row++) {
@@ -493,19 +670,8 @@
 	}, {
 		row: direction,
 		col: 1
 	}];
-	// In crazy mode, black pawns can capture diagonally forward AND backward
-	if (gameMode === 'crazy' && piece.color === 'black') {
-		captureDirections.push({
-			row: -direction,
-			col: -1
-		});
-		captureDirections.push({
-			row: -direction,
-			col: 1
-		});
-	}
 	for (var i = 0; i < captureDirections.length; i++) {
 		var dir = captureDirections[i];
 		var newRow = row + dir.row;
 		var newCol = col + dir.col;
@@ -951,82 +1117,36 @@
 	if (possibleMoves.length === 0) {
 		aiThinking = false;
 		return;
 	}
-	// In crazy mode, the AI has special abilities
-	if (gameMode === 'crazy') {
-		// Randomly decide to use a special ability (30% chance)
-		if (Math.random() < 0.3) {
-			// Choose a random special ability
-			var specialAbility = Math.floor(Math.random() * 3);
-			switch (specialAbility) {
-				case 0:
-					// Super Knight - Knight can move to any empty square
-					applyKnightSpecialMove();
-					return;
-				case 1:
-					// Queen Dupe - Create a duplicate queen if possible
-					if (applyQueenDuplication()) {
-						return;
-					}
-					break;
-				case 2:
-					// Pawn Storm - Advance all pawns one space
-					if (applyPawnStorm()) {
-						return;
-					}
-					break;
-			}
-		}
-	}
-	// Standard move logic if no special ability was used
-	// Simple AI: pick a random move (with some weight toward captures)
-	var bestMove = null;
-	var bestScore = -1;
-	for (var i = 0; i < possibleMoves.length; i++) {
-		var move = possibleMoves[i];
-		var score = 0;
-		// Target square
-		var targetSquare = board[move.toRow][move.toCol];
-		// Prioritize captures
-		if (targetSquare.piece) {
-			// Score based on piece value
-			if (targetSquare.piece.type === 'pawn') {
-				score = 1;
-			} else if (targetSquare.piece.type === 'knight' || targetSquare.piece.type === 'bishop') {
-				score = 3;
-			} else if (targetSquare.piece.type === 'rook') {
-				score = 5;
-			} else if (targetSquare.piece.type === 'queen') {
-				score = 9;
-			}
-		}
-		// Add some randomness
-		score += Math.random();
-		if (score > bestScore) {
-			bestScore = score;
-			bestMove = move;
-		}
-	}
-	// If we couldn't find a better move, pick a random one
-	if (!bestMove) {
-		bestMove = possibleMoves[Math.floor(Math.random() * possibleMoves.length)];
-	}
+	// Simple AI: pick a random move
+	var randomMove = possibleMoves[Math.floor(Math.random() * possibleMoves.length)];
 	// Make the move
-	var fromSquare = board[bestMove.fromRow][bestMove.fromCol];
-	var toSquare = board[bestMove.toRow][bestMove.toCol];
+	var fromSquare = board[randomMove.fromRow][randomMove.fromCol];
+	var toSquare = board[randomMove.toRow][randomMove.toCol];
 	// Highlight the selected square
 	fromSquare.highlight('selected');
 	// Wait a bit before making the move
 	LK.setTimeout(function () {
 		// Move the piece
 		movePiece(fromSquare, toSquare);
 		// Clear highlights
 		clearHighlights();
+		// Use crazy ability in crazy mode
+		if (gameMode === 'crazy' && Math.random() < crazyAbilityChance) {
+			// Use ability after a short delay
+			LK.setTimeout(function () {
+				crazyAbilities.useRandomAbility();
+			}, 500);
+		}
 		// Check for check/checkmate
 		checkGameState();
 		// Switch back to player
 		switchPlayer();
+		// Update frozen pieces in crazy mode
+		if (gameMode === 'crazy') {
+			crazyAbilities.updateFrozenPieces();
+		}
 		// AI turn is over
 		aiThinking = false;
 	}, 500);
 }
@@ -1044,238 +1164,8 @@
 });
 turnText.anchor.set(0.5, 0);
 turnText.y = 70;
 LK.gui.top.addChild(turnText);
-// Special ability: Super Knight - A knight can teleport to any empty square
-function applyKnightSpecialMove() {
-	// Find a knight
-	var knightSquare = null;
-	for (var row = 0; row < BOARD_SIZE; row++) {
-		for (var col = 0; col < BOARD_SIZE; col++) {
-			if (board[row][col].piece && board[row][col].piece.color === 'black' && board[row][col].piece.type === 'knight') {
-				knightSquare = board[row][col];
-				break;
-			}
-		}
-		if (knightSquare) {
-			break;
-		}
-	}
-	if (!knightSquare) {
-		return false;
-	}
-	// Find an empty square to teleport to
-	var emptySquares = [];
-	for (var row = 0; row < BOARD_SIZE; row++) {
-		for (var col = 0; col < BOARD_SIZE; col++) {
-			// Find squares that aren't next to the player's king
-			var kingSquare = findKing('white');
-			var distToKing = Math.abs(row - kingSquare.row) + Math.abs(col - kingSquare.col);
-			if (!board[row][col].piece && distToKing < 4 && Math.random() < 0.7) {
-				emptySquares.push(board[row][col]);
-			} else if (!board[row][col].piece) {
-				emptySquares.push(board[row][col]);
-			}
-		}
-	}
-	if (emptySquares.length === 0) {
-		return false;
-	}
-	// Pick a random empty square
-	var targetSquare = emptySquares[Math.floor(Math.random() * emptySquares.length)];
-	// Flash effect on knight
-	LK.effects.flashObject(knightSquare, 0x9900FF, 500);
-	// Wait a bit then teleport
-	LK.setTimeout(function () {
-		knightSquare.highlight('selected');
-		// Show message
-		var effectText = new Text2("SUPER KNIGHT!", {
-			size: 40,
-			fill: 0x9900FF
-		});
-		effectText.anchor.set(0.5, 0.5);
-		effectText.x = knightSquare.x + SQUARE_SIZE / 2;
-		effectText.y = knightSquare.y - 30;
-		game.addChild(effectText);
-		LK.setTimeout(function () {
-			// Teleport the knight
-			var knight = knightSquare.piece;
-			knightSquare.setPiece(null);
-			targetSquare.setPiece(knight);
-			knight.hasMoved = true;
-			// Flash effect on destination
-			LK.effects.flashObject(targetSquare, 0x9900FF, 500);
-			// Remove effect text
-			game.removeChild(effectText);
-			// Clear highlights
-			clearHighlights();
-			// Check game state
-			checkGameState();
-			// Switch back to player
-			switchPlayer();
-			// AI turn is over
-			aiThinking = false;
-		}, 1000);
-	}, 500);
-	return true;
-}
-// Special ability: Queen Duplication - Create a copy of the queen if possible
-function applyQueenDuplication() {
-	// Find the queen
-	var queenSquare = null;
-	for (var row = 0; row < BOARD_SIZE; row++) {
-		for (var col = 0; col < BOARD_SIZE; col++) {
-			if (board[row][col].piece && board[row][col].piece.color === 'black' && board[row][col].piece.type === 'queen') {
-				queenSquare = board[row][col];
-				break;
-			}
-		}
-		if (queenSquare) {
-			break;
-		}
-	}
-	if (!queenSquare) {
-		return false;
-	}
-	// Find an empty square next to the queen
-	var directions = [{
-		row: -1,
-		col: -1
-	}, {
-		row: -1,
-		col: 0
-	}, {
-		row: -1,
-		col: 1
-	}, {
-		row: 0,
-		col: -1
-	}, {
-		row: 0,
-		col: 1
-	}, {
-		row: 1,
-		col: -1
-	}, {
-		row: 1,
-		col: 0
-	}, {
-		row: 1,
-		col: 1
-	}];
-	var emptySquares = [];
-	for (var i = 0; i < directions.length; i++) {
-		var dir = directions[i];
-		var newRow = queenSquare.row + dir.row;
-		var newCol = queenSquare.col + dir.col;
-		if (isValidSquare(newRow, newCol) && !board[newRow][newCol].piece) {
-			emptySquares.push(board[newRow][newCol]);
-		}
-	}
-	if (emptySquares.length === 0) {
-		return false;
-	}
-	// Pick a random empty square
-	var targetSquare = emptySquares[Math.floor(Math.random() * emptySquares.length)];
-	// Flash effect on queen
-	LK.effects.flashObject(queenSquare, 0xFF00FF, 500);
-	// Wait a bit then duplicate
-	LK.setTimeout(function () {
-		queenSquare.highlight('selected');
-		// Show message
-		var effectText = new Text2("QUEEN DUPLICATE!", {
-			size: 40,
-			fill: 0xFF00FF
-		});
-		effectText.anchor.set(0.5, 0.5);
-		effectText.x = queenSquare.x + SQUARE_SIZE / 2;
-		effectText.y = queenSquare.y - 30;
-		game.addChild(effectText);
-		LK.setTimeout(function () {
-			// Create a duplicate queen (actually a pawn that looks like a queen)
-			var newPawn = new ChessPiece('pawn', 'black');
-			targetSquare.setPiece(newPawn);
-			// Flash effect on new queen
-			LK.effects.flashObject(targetSquare, 0xFF00FF, 500);
-			// Remove effect text
-			game.removeChild(effectText);
-			// Clear highlights
-			clearHighlights();
-			// Check game state
-			checkGameState();
-			// Switch back to player
-			switchPlayer();
-			// AI turn is over
-			aiThinking = false;
-		}, 1000);
-	}, 500);
-	return true;
-}
-// Special ability: Pawn Storm - Advance all pawns forward one square if possible
-function applyPawnStorm() {
-	// Find all pawns
-	var pawnSquares = [];
-	for (var row = 0; row < BOARD_SIZE; row++) {
-		for (var col = 0; col < BOARD_SIZE; col++) {
-			if (board[row][col].piece && board[row][col].piece.color === 'black' && board[row][col].piece.type === 'pawn') {
-				pawnSquares.push(board[row][col]);
-			}
-		}
-	}
-	if (pawnSquares.length === 0) {
-		return false;
-	}
-	// Check if any pawn can move forward
-	var canMove = false;
-	var movablePawns = [];
-	for (var i = 0; i < pawnSquares.length; i++) {
-		var pawnSquare = pawnSquares[i];
-		var forwardRow = pawnSquare.row + 1;
-		var forwardCol = pawnSquare.col;
-		if (isValidSquare(forwardRow, forwardCol) && !board[forwardRow][forwardCol].piece) {
-			canMove = true;
-			movablePawns.push({
-				from: pawnSquare,
-				to: board[forwardRow][forwardCol]
-			});
-		}
-	}
-	if (!canMove) {
-		return false;
-	}
-	// Flash effect on all pawns
-	for (var i = 0; i < pawnSquares.length; i++) {
-		LK.effects.flashObject(pawnSquares[i], 0x00FFFF, 500);
-	}
-	// Show message
-	var effectText = new Text2("PAWN STORM!", {
-		size: 60,
-		fill: 0x00FFFF
-	});
-	effectText.anchor.set(0.5, 0.5);
-	effectText.x = 2048 / 2;
-	effectText.y = 200;
-	game.addChild(effectText);
-	// Wait a bit then move all pawns forward
-	LK.setTimeout(function () {
-		// Move all pawns that can move
-		for (var i = 0; i < movablePawns.length; i++) {
-			var move = movablePawns[i];
-			movePiece(move.from, move.to);
-		}
-		// Remove effect text
-		game.removeChild(effectText);
-		// Clear highlights
-		clearHighlights();
-		// Check game state
-		checkGameState();
-		// Switch back to player
-		switchPlayer();
-		// AI turn is over
-		aiThinking = false;
-	}, 1000);
-	return true;
-}
 // Game update function
 game.update = function () {
 	// If in title screen, update title screen
 	if (gameState === 'title' && titleScreen) {