/**** 
* 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 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.to(bg, 0.1, {
					alpha: 1,
					onComplete: function onComplete() {
						tween.to(bg, 0.1, {
							alpha: 0.7
						});
					}
				});
				// 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'
// 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;
	}
	// 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();
		// Check for check/checkmate
		checkGameState();
		// Switch back to player
		switchPlayer();
		// 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,124 @@
 		game.selectSquare(self);
 	};
 	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.to(bg, 0.1, {
+					alpha: 1,
+					onComplete: function onComplete() {
+						tween.to(bg, 0.1, {
+							alpha: 0.7
+						});
+					}
+				});
+				// 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', {
@@ -120,9 +236,9 @@
 		startButton.scale.set(pulseScale);
 	};
 	// Handle tap anywhere to start
 	self.down = function () {
-		game.startGame();
+		game.showGameModeScreen();
 	};
 	return self;
 });
 
@@ -145,11 +261,13 @@
 var board = [];
 var selectedSquare = null;
 var validMoves = [];
 var currentPlayer = 'white';
-var gameState = 'title'; // 'title', 'playing', 'check', 'checkmate', 'stalemate'
+var gameState = 'title'; // 'title', 'modeSelect', 'playing', 'check', 'checkmate', 'stalemate'
 var aiThinking = false;
 var titleScreen = null;
+var gameModeScreen = null;
+var gameMode = 'classic'; // 'classic', 'crazy', 'tournament'
 // Initialize the chess board
 function initializeBoard() {
 	board = [];
 	// Create the 8x8 chess board
@@ -829,8 +947,13 @@
 	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!');
@@ -844,17 +967,53 @@
 	} else {
 		turnText.setText(currentPlayer === 'white' ? 'Your Turn' : 'AI Turn');
 	}
 };
-// Method to start the game from title screen
-game.startGame = function () {
-	// Remove title screen
+// 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;
@@ -866,5 +1025,6 @@
 titleScreen.y = 2732 / 2;
 game.addChild(titleScreen);
 // Hide score and turn text initially
 scoreTxt.visible = false;
-turnText.visible = false;
\ No newline at end of file
+turnText.visible = false;
+;
\ No newline at end of file