/**** 
* 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.color = color;
	self.row = row;
	self.col = col;
	self.hasMoved = false;
	var assetName = color + type.charAt(0).toUpperCase() + type.slice(1);
	self.graphic = self.attachAsset(assetName, {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.setPosition = function (row, col) {
		self.row = row;
		self.col = col;
		if (playerPerspective === 'black') {
			// Flip the board for black player perspective
			self.x = boardOffsetX + (7 - col) * 200 + 100;
			self.y = boardOffsetY + (7 - row) * 200 + 100;
		} else {
			self.x = boardOffsetX + col * 200 + 100;
			self.y = boardOffsetY + row * 200 + 100;
		}
	};
	self.getValidMoves = function () {
		var moves = [];
		if (self.pieceType === 'pawn') {
			// Pawns move diagonally forward, capture straight forward
			var direction = self.color === 'white' ? -1 : 1;
			var newRow = self.row + direction;
			// Diagonal movement (normal pawn movement)
			if (newRow >= 0 && newRow < 8) {
				if (self.col > 0 && !board[newRow][self.col - 1]) {
					moves.push({
						row: newRow,
						col: self.col - 1
					});
				}
				if (self.col < 7 && !board[newRow][self.col + 1]) {
					moves.push({
						row: newRow,
						col: self.col + 1
					});
				}
			}
			// Capture straight forward
			if (newRow >= 0 && newRow < 8) {
				var piece = board[newRow][self.col];
				if (piece && piece.color !== self.color) {
					moves.push({
						row: newRow,
						col: self.col
					});
				}
			}
			// Initial two-square diagonal move
			if (!self.hasMoved) {
				newRow = self.row + direction * 2;
				if (newRow >= 0 && newRow < 8) {
					if (self.col > 1 && !board[newRow][self.col - 2]) {
						moves.push({
							row: newRow,
							col: self.col - 2
						});
					}
					if (self.col < 6 && !board[newRow][self.col + 2]) {
						moves.push({
							row: newRow,
							col: self.col + 2
						});
					}
				}
			}
		} else if (self.pieceType === 'rook') {
			// Rooks move diagonally (like bishops)
			var directions = [[-1, -1], [-1, 1], [1, -1], [1, 1]];
			for (var d = 0; d < directions.length; d++) {
				var dir = directions[d];
				for (var i = 1; i < 8; i++) {
					var newRow = self.row + dir[0] * i;
					var newCol = self.col + dir[1] * i;
					if (newRow < 0 || newRow >= 8 || newCol < 0 || newCol >= 8) break;
					var piece = board[newRow][newCol];
					if (!piece) {
						moves.push({
							row: newRow,
							col: newCol
						});
					} else {
						if (piece.color !== self.color) {
							moves.push({
								row: newRow,
								col: newCol
							});
						}
						break;
					}
				}
			}
		} else if (self.pieceType === 'bishop') {
			// Bishops move like knights (L-shaped)
			var knightMoves = [[-2, -1], [-2, 1], [-1, -2], [-1, 2], [1, -2], [1, 2], [2, -1], [2, 1]];
			for (var k = 0; k < knightMoves.length; k++) {
				var move = knightMoves[k];
				var newRow = self.row + move[0];
				var newCol = self.col + move[1];
				if (newRow >= 0 && newRow < 8 && newCol >= 0 && newCol < 8) {
					var piece = board[newRow][newCol];
					if (!piece || piece.color !== self.color) {
						moves.push({
							row: newRow,
							col: newCol
						});
					}
				}
			}
		} else if (self.pieceType === 'knight') {
			// Knights move straight (like rooks)
			var directions = [[0, 1], [0, -1], [1, 0], [-1, 0]];
			for (var d = 0; d < directions.length; d++) {
				var dir = directions[d];
				for (var i = 1; i < 8; i++) {
					var newRow = self.row + dir[0] * i;
					var newCol = self.col + dir[1] * i;
					if (newRow < 0 || newRow >= 8 || newCol < 0 || newCol >= 8) break;
					var piece = board[newRow][newCol];
					if (!piece) {
						moves.push({
							row: newRow,
							col: newCol
						});
					} else {
						if (piece.color !== self.color) {
							moves.push({
								row: newRow,
								col: newCol
							});
						}
						break;
					}
				}
			}
		} else if (self.pieceType === 'queen') {
			// Queen moves both diagonally and straight
			var directions = [[-1, -1], [-1, 0], [-1, 1], [0, -1], [0, 1], [1, -1], [1, 0], [1, 1]];
			for (var d = 0; d < directions.length; d++) {
				var dir = directions[d];
				for (var i = 1; i < 8; i++) {
					var newRow = self.row + dir[0] * i;
					var newCol = self.col + dir[1] * i;
					if (newRow < 0 || newRow >= 8 || newCol < 0 || newCol >= 8) break;
					var piece = board[newRow][newCol];
					if (!piece) {
						moves.push({
							row: newRow,
							col: newCol
						});
					} else {
						if (piece.color !== self.color) {
							moves.push({
								row: newRow,
								col: newCol
							});
						}
						break;
					}
				}
			}
		} else if (self.pieceType === 'king') {
			// King moves one square in any direction
			var directions = [[-1, -1], [-1, 0], [-1, 1], [0, -1], [0, 1], [1, -1], [1, 0], [1, 1]];
			for (var d = 0; d < directions.length; d++) {
				var dir = directions[d];
				var newRow = self.row + dir[0];
				var newCol = self.col + dir[1];
				if (newRow >= 0 && newRow < 8 && newCol >= 0 && newCol < 8) {
					var piece = board[newRow][newCol];
					if (!piece || piece.color !== self.color) {
						moves.push({
							row: newRow,
							col: newCol
						});
					}
				}
			}
		}
		return moves;
	};
	return self;
});
var ChessSquare = Container.expand(function (row, col) {
	var self = Container.call(this);
	self.row = row;
	self.col = col;
	self.isLight = (row + col) % 2 === 0;
	self.background = self.attachAsset(self.isLight ? 'lightSquare' : 'darkSquare', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.highlight = self.attachAsset('highlight', {
		anchorX: 0.5,
		anchorY: 0.5,
		alpha: 0
	});
	self.validMoveIndicator = self.attachAsset('validMove', {
		anchorX: 0.5,
		anchorY: 0.5,
		alpha: 0
	});
	self.selectedIndicator = self.attachAsset('selectedPiece', {
		anchorX: 0.5,
		anchorY: 0.5,
		alpha: 0
	});
	self.setHighlight = function (show) {
		self.highlight.alpha = show ? 0.3 : 0;
	};
	self.setValidMove = function (show) {
		self.validMoveIndicator.alpha = show ? 0.5 : 0;
	};
	self.setSelected = function (show) {
		self.selectedIndicator.alpha = show ? 0.4 : 0;
	};
	self.down = function (x, y, obj) {
		handleSquareClick(self.row, self.col);
	};
	return self;
});
var PromotionDialog = Container.expand(function (color, onSelect) {
	var self = Container.call(this);
	self.color = color;
	self.onSelect = onSelect;
	// Background
	self.background = self.attachAsset('promotionDialog', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Title text
	self.titleText = new Text2('Choose promotion piece:', {
		size: 60,
		fill: 0xFFFFFF
	});
	self.titleText.anchor.set(0.5, 0.5);
	self.titleText.x = 0;
	self.titleText.y = -120;
	self.addChild(self.titleText);
	// Promotion pieces
	var pieceTypes = ['queen', 'rook', 'bishop', 'knight'];
	var buttons = [];
	for (var i = 0; i < pieceTypes.length; i++) {
		var pieceType = pieceTypes[i];
		var button = new Container();
		// Button background
		var buttonBg = button.attachAsset('promotionButton', {
			anchorX: 0.5,
			anchorY: 0.5
		});
		// Piece image
		var assetName = color + pieceType.charAt(0).toUpperCase() + pieceType.slice(1);
		var pieceImage = button.attachAsset(assetName, {
			anchorX: 0.5,
			anchorY: 0.5
		});
		button.x = (i - 1.5) * 180;
		button.y = 0;
		button.pieceType = pieceType;
		// Create closure to capture the correct pieceType for each button
		button.down = function (capturedPieceType) {
			return function (x, y, obj) {
				self.onSelect(capturedPieceType);
			};
		}(pieceType);
		buttons.push(button);
		self.addChild(button);
	}
	// Position dialog at center of screen
	self.x = 1024;
	self.y = 1366;
	return self;
});

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

/**** 
* Game Code
****/ 
// White pieces
// Black pieces
var boardOffsetX = 224;
var boardOffsetY = 566;
var board = [];
var squares = [];
var pieces = [];
var selectedPiece = null;
var validMoves = [];
var currentPlayer = 'white';
var gameOver = false;
var promotionDialog = null;
var pendingPromotion = null;
var playerPerspective = 'white'; // 'white' or 'black' - determines board orientation
var gameMode = 'menu'; // 'menu', 'computer', 'online'
var isPlayerTurn = true;
var aiColor = 'black';
var mainMenu = null;
function createMainMenu() {
	mainMenu = new Container();
	game.addChild(mainMenu);
	// Title
	var titleText = new Text2('Chess Game', {
		size: 120,
		fill: 0xFFFFFF
	});
	titleText.anchor.set(0.5, 0.5);
	titleText.x = 1024;
	titleText.y = 600;
	mainMenu.addChild(titleText);
	// Computer button
	var computerButton = new Container();
	var computerBg = computerButton.attachAsset('promotionDialog', {
		anchorX: 0.5,
		anchorY: 0.5,
		scaleX: 0.8,
		scaleY: 0.4
	});
	var computerText = new Text2('Computer', {
		size: 80,
		fill: 0xFFFFFF
	});
	computerText.anchor.set(0.5, 0.5);
	computerButton.addChild(computerText);
	computerButton.x = 1024;
	computerButton.y = 900;
	computerButton.down = function (x, y, obj) {
		startComputerGame();
	};
	mainMenu.addChild(computerButton);
	// Online button
	var onlineButton = new Container();
	var onlineBg = onlineButton.attachAsset('promotionDialog', {
		anchorX: 0.5,
		anchorY: 0.5,
		scaleX: 0.8,
		scaleY: 0.4
	});
	var onlineText = new Text2('Online', {
		size: 80,
		fill: 0xFFFFFF
	});
	onlineText.anchor.set(0.5, 0.5);
	onlineButton.addChild(onlineText);
	onlineButton.x = 1024;
	onlineButton.y = 1200;
	onlineButton.down = function (x, y, obj) {
		startOnlineGame();
	};
	mainMenu.addChild(onlineButton);
}
function startComputerGame() {
	gameMode = 'computer';
	// Randomly assign player color
	var playerColor = Math.random() < 0.5 ? 'white' : 'black';
	playerPerspective = playerColor;
	aiColor = playerColor === 'white' ? 'black' : 'white';
	isPlayerTurn = currentPlayer === playerColor;
	// Hide menu and initialize game
	mainMenu.destroy();
	mainMenu = null;
	initializeBoard();
	initializePieces();
	addCoordinateLabels();
	createTurnIndicator();
}
function startOnlineGame() {
	gameMode = 'online';
	// For now, just start a regular game - online functionality to be implemented later
	playerPerspective = 'white';
	mainMenu.destroy();
	mainMenu = null;
	initializeBoard();
	initializePieces();
	addCoordinateLabels();
	createTurnIndicator();
}
function initializeBoard() {
	// Initialize board
	for (var row = 0; row < 8; row++) {
		board[row] = [];
		squares[row] = [];
		for (var col = 0; col < 8; col++) {
			board[row][col] = null;
			var square = new ChessSquare(row, col);
			if (playerPerspective === 'black') {
				// Flip the board for black player perspective
				square.x = boardOffsetX + (7 - col) * 200 + 100;
				square.y = boardOffsetY + (7 - row) * 200 + 100;
			} else {
				square.x = boardOffsetX + col * 200 + 100;
				square.y = boardOffsetY + row * 200 + 100;
			}
			squares[row][col] = square;
			game.addChild(square);
		}
	}
}
// Show main menu on startup
createMainMenu();
// Initialize pieces
function initializePieces() {
	// White pieces
	var whitePieces = [{
		type: 'rook',
		positions: [[7, 0], [7, 7]]
	}, {
		type: 'knight',
		positions: [[7, 1], [7, 6]]
	}, {
		type: 'bishop',
		positions: [[7, 2], [7, 5]]
	}, {
		type: 'queen',
		positions: [[7, 3]]
	}, {
		type: 'king',
		positions: [[7, 4]]
	}, {
		type: 'pawn',
		positions: [[6, 0], [6, 1], [6, 2], [6, 3], [6, 4], [6, 5], [6, 6], [6, 7]]
	}];
	// Black pieces
	var blackPieces = [{
		type: 'rook',
		positions: [[0, 0], [0, 7]]
	}, {
		type: 'knight',
		positions: [[0, 1], [0, 6]]
	}, {
		type: 'bishop',
		positions: [[0, 2], [0, 5]]
	}, {
		type: 'queen',
		positions: [[0, 3]]
	}, {
		type: 'king',
		positions: [[0, 4]]
	}, {
		type: 'pawn',
		positions: [[1, 0], [1, 1], [1, 2], [1, 3], [1, 4], [1, 5], [1, 6], [1, 7]]
	}];
	// Create white pieces
	for (var i = 0; i < whitePieces.length; i++) {
		var pieceData = whitePieces[i];
		for (var j = 0; j < pieceData.positions.length; j++) {
			var pos = pieceData.positions[j];
			var piece = new ChessPiece(pieceData.type, 'white', pos[0], pos[1]);
			piece.setPosition(pos[0], pos[1]);
			board[pos[0]][pos[1]] = piece;
			pieces.push(piece);
			game.addChild(piece);
		}
	}
	// Create black pieces
	for (var i = 0; i < blackPieces.length; i++) {
		var pieceData = blackPieces[i];
		for (var j = 0; j < pieceData.positions.length; j++) {
			var pos = pieceData.positions[j];
			var piece = new ChessPiece(pieceData.type, 'black', pos[0], pos[1]);
			piece.setPosition(pos[0], pos[1]);
			board[pos[0]][pos[1]] = piece;
			pieces.push(piece);
			game.addChild(piece);
		}
	}
}
function clearHighlights() {
	for (var row = 0; row < 8; row++) {
		for (var col = 0; col < 8; col++) {
			squares[row][col].setHighlight(false);
			squares[row][col].setValidMove(false);
			squares[row][col].setSelected(false);
		}
	}
}
function showValidMoves(piece) {
	var allMoves = piece.getValidMoves();
	validMoves = [];
	// Filter out moves that would leave the king in check
	for (var i = 0; i < allMoves.length; i++) {
		var move = allMoves[i];
		if (isValidMove(piece, move.row, move.col)) {
			validMoves.push(move);
			squares[move.row][move.col].setValidMove(true);
		}
	}
}
function handleSquareClick(row, col) {
	if (gameOver) return;
	if (gameMode === 'computer' && !isPlayerTurn) return; // Don't allow moves during AI turn
	if (gameMode === 'menu') return; // Don't allow moves in menu
	var clickedPiece = board[row][col];
	if (selectedPiece) {
		// Check if clicked square is a valid move
		var validMove = false;
		for (var i = 0; i < validMoves.length; i++) {
			if (validMoves[i].row === row && validMoves[i].col === col) {
				validMove = true;
				break;
			}
		}
		if (validMove) {
			// Make the move
			movePiece(selectedPiece, row, col);
			selectedPiece = null;
			clearHighlights();
			validMoves = [];
			// Only switch players and check game over if not promoting
			if (!pendingPromotion) {
				// Switch players
				currentPlayer = currentPlayer === 'white' ? 'black' : 'white';
				if (gameMode === 'computer') {
					isPlayerTurn = currentPlayer !== aiColor;
				}
				// Check for game over conditions
				checkGameOver();
				if (gameMode === 'computer' && !isPlayerTurn) {
					// AI turn - make move after short delay
					LK.setTimeout(function () {
						makeAIMove();
					}, 800);
				}
			}
		} else if (clickedPiece && clickedPiece.color === currentPlayer) {
			// Select new piece
			clearHighlights();
			selectedPiece = clickedPiece;
			squares[row][col].setSelected(true);
			showValidMoves(selectedPiece);
		} else {
			// Deselect
			selectedPiece = null;
			clearHighlights();
			validMoves = [];
		}
	} else if (clickedPiece && clickedPiece.color === currentPlayer) {
		// Select piece
		selectedPiece = clickedPiece;
		squares[row][col].setSelected(true);
		showValidMoves(selectedPiece);
	}
}
function movePiece(piece, toRow, toCol) {
	var capturedPiece = board[toRow][toCol];
	// Remove piece from old position
	board[piece.row][piece.col] = null;
	// Place piece in new position
	board[toRow][toCol] = piece;
	piece.setPosition(toRow, toCol);
	piece.hasMoved = true;
	// Handle captured piece
	if (capturedPiece) {
		capturedPiece.destroy();
		for (var i = pieces.length - 1; i >= 0; i--) {
			if (pieces[i] === capturedPiece) {
				pieces.splice(i, 1);
				break;
			}
		}
		LK.getSound('capture').play();
	} else {
		LK.getSound('move').play();
	}
	// Animate piece movement
	tween(piece, {
		x: piece.x,
		y: piece.y
	}, {
		duration: 300
	});
	// Check for pawn promotion
	if (piece.pieceType === 'pawn') {
		var promotionRow = piece.color === 'white' ? 0 : 7;
		if (toRow === promotionRow) {
			// Store promotion details
			pendingPromotion = {
				piece: piece,
				row: toRow,
				col: toCol
			};
			// Show promotion dialog
			showPromotionDialog(piece.color);
			return; // Don't switch players yet
		}
	}
}
function isKingInCheck(kingColor) {
	// Find the king
	var king = null;
	for (var i = 0; i < pieces.length; i++) {
		var piece = pieces[i];
		if (piece.pieceType === 'king' && piece.color === kingColor) {
			king = piece;
			break;
		}
	}
	if (!king) return false;
	// Check if any enemy piece can attack the king
	for (var i = 0; i < pieces.length; i++) {
		var piece = pieces[i];
		if (piece.color !== kingColor) {
			var moves = piece.getValidMoves();
			for (var j = 0; j < moves.length; j++) {
				if (moves[j].row === king.row && moves[j].col === king.col) {
					return true;
				}
			}
		}
	}
	return false;
}
function isValidMove(piece, toRow, toCol) {
	// Save current state
	var originalRow = piece.row;
	var originalCol = piece.col;
	var capturedPiece = board[toRow][toCol];
	// Temporarily remove captured piece from pieces array for accurate check detection
	var capturedPieceIndex = -1;
	if (capturedPiece) {
		for (var i = 0; i < pieces.length; i++) {
			if (pieces[i] === capturedPiece) {
				capturedPieceIndex = i;
				pieces.splice(i, 1);
				break;
			}
		}
	}
	// Simulate the move
	board[originalRow][originalCol] = null;
	board[toRow][toCol] = piece;
	piece.row = toRow;
	piece.col = toCol;
	// Check if this move leaves the king in check
	var kingInCheck = isKingInCheck(piece.color);
	// Restore original state
	board[originalRow][originalCol] = piece;
	board[toRow][toCol] = capturedPiece;
	piece.row = originalRow;
	piece.col = originalCol;
	// Restore captured piece to pieces array
	if (capturedPiece && capturedPieceIndex !== -1) {
		pieces.splice(capturedPieceIndex, 0, capturedPiece);
	}
	// Debug: Log when moves are being blocked
	if (kingInCheck && capturedPiece) {
		console.log("Move blocked: " + piece.pieceType + " cannot capture " + capturedPiece.pieceType + " - king still in check");
	}
	return !kingInCheck;
}
function getValidMovesForPlayer(playerColor) {
	var allMoves = [];
	for (var i = 0; i < pieces.length; i++) {
		var piece = pieces[i];
		if (piece.color === playerColor) {
			var moves = piece.getValidMoves();
			for (var j = 0; j < moves.length; j++) {
				if (isValidMove(piece, moves[j].row, moves[j].col)) {
					allMoves.push({
						piece: piece,
						row: moves[j].row,
						col: moves[j].col
					});
				}
			}
		}
	}
	return allMoves;
}
function makeAIMove() {
	if (gameMode !== 'computer' || currentPlayer !== aiColor || gameOver) return;
	var validMoves = getValidMovesForPlayer(aiColor);
	if (validMoves.length === 0) return;
	// Simple AI: pick a random valid move
	var randomMove = validMoves[Math.floor(Math.random() * validMoves.length)];
	movePiece(randomMove.piece, randomMove.row, randomMove.col);
	// Clear selection and highlights
	selectedPiece = null;
	clearHighlights();
	// Switch players if not promoting
	if (!pendingPromotion) {
		currentPlayer = currentPlayer === 'white' ? 'black' : 'white';
		isPlayerTurn = currentPlayer !== aiColor;
		checkGameOver();
	}
}
function checkGameOver() {
	// Find kings
	var whiteKing = null;
	var blackKing = null;
	for (var i = 0; i < pieces.length; i++) {
		var piece = pieces[i];
		if (piece.pieceType === 'king') {
			if (piece.color === 'white') {
				whiteKing = piece;
			} else {
				blackKing = piece;
			}
		}
	}
	// Check if either king is captured (shouldn't happen in proper chess)
	if (!whiteKing) {
		gameOver = true;
		LK.setTimeout(function () {
			LK.showGameOver();
		}, 1000);
		return;
	} else if (!blackKing) {
		gameOver = true;
		LK.setTimeout(function () {
			LK.showYouWin();
		}, 1000);
		return;
	}
	// Check for check and checkmate
	var currentPlayerInCheck = isKingInCheck(currentPlayer);
	var validMoves = getValidMovesForPlayer(currentPlayer);
	if (currentPlayerInCheck) {
		if (validMoves.length === 0) {
			// Checkmate
			gameOver = true;
			if (currentPlayer === 'white') {
				LK.setTimeout(function () {
					LK.showGameOver();
				}, 1000);
			} else {
				LK.setTimeout(function () {
					LK.showYouWin();
				}, 1000);
			}
		} else {
			// Check warning
			LK.effects.flashScreen(0xff0000, 500);
		}
	} else if (validMoves.length === 0) {
		// Stalemate
		gameOver = true;
		LK.setTimeout(function () {
			LK.showGameOver();
		}, 1000);
	}
}
function showPromotionDialog(color) {
	if (promotionDialog) {
		promotionDialog.destroy();
	}
	promotionDialog = new PromotionDialog(color, function (selectedPiece) {
		handlePromotion(selectedPiece);
	});
	game.addChild(promotionDialog);
}
function handlePromotion(newPieceType) {
	if (!pendingPromotion) return;
	var oldPiece = pendingPromotion.piece;
	var row = pendingPromotion.row;
	var col = pendingPromotion.col;
	// Remove old pawn
	oldPiece.destroy();
	for (var i = pieces.length - 1; i >= 0; i--) {
		if (pieces[i] === oldPiece) {
			pieces.splice(i, 1);
			break;
		}
	}
	board[row][col] = null;
	// Create new piece
	var newPiece = new ChessPiece(newPieceType, oldPiece.color, row, col);
	newPiece.setPosition(row, col);
	newPiece.hasMoved = true;
	board[row][col] = newPiece;
	pieces.push(newPiece);
	game.addChild(newPiece);
	// Clean up
	promotionDialog.destroy();
	promotionDialog = null;
	pendingPromotion = null;
	// Switch players
	currentPlayer = currentPlayer === 'white' ? 'black' : 'white';
	// Check for game over conditions
	checkGameOver();
}
function setPlayerPerspective(perspective) {
	playerPerspective = perspective;
	// Clear existing board and pieces
	for (var i = pieces.length - 1; i >= 0; i--) {
		pieces[i].destroy();
	}
	pieces = [];
	for (var row = 0; row < 8; row++) {
		for (var col = 0; col < 8; col++) {
			board[row][col] = null;
			squares[row][col].destroy();
		}
	}
	// Clear coordinate labels
	for (var i = game.children.length - 1; i >= 0; i--) {
		var child = game.children[i];
		if (child instanceof Text2 && child !== turnText) {
			child.destroy();
		}
	}
	// Reinitialize board
	for (var row = 0; row < 8; row++) {
		board[row] = [];
		squares[row] = [];
		for (var col = 0; col < 8; col++) {
			board[row][col] = null;
			var square = new ChessSquare(row, col);
			if (playerPerspective === 'black') {
				square.x = boardOffsetX + (7 - col) * 200 + 100;
				square.y = boardOffsetY + (7 - row) * 200 + 100;
			} else {
				square.x = boardOffsetX + col * 200 + 100;
				square.y = boardOffsetY + row * 200 + 100;
			}
			squares[row][col] = square;
			game.addChild(square);
		}
	}
	// Reinitialize pieces and coordinates
	initializePieces();
	addCoordinateLabels();
}
function addCoordinateLabels() {
	// Add numbers 1-8 on the left side (always from white's perspective)
	for (var i = 0; i < 8; i++) {
		var rankNumber, rankY;
		if (playerPerspective === 'black') {
			rankNumber = i + 1;
			rankY = boardOffsetY + i * 200 + 100;
		} else {
			rankNumber = 8 - i;
			rankY = boardOffsetY + i * 200 + 100;
		}
		var rankText = new Text2(rankNumber.toString(), {
			size: 40,
			fill: 0xFFFFFF
		});
		rankText.anchor.set(0.5, 0.5);
		rankText.x = boardOffsetX - 60;
		rankText.y = rankY;
		game.addChild(rankText);
	}
	// Add letters a-h (always from white's perspective)
	var files = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'];
	for (var i = 0; i < 8; i++) {
		var fileLabel, fileX;
		if (playerPerspective === 'black') {
			fileLabel = files[7 - i];
			fileX = boardOffsetX + i * 200 + 100;
		} else {
			fileLabel = files[i];
			fileX = boardOffsetX + i * 200 + 100;
		}
		var fileText = new Text2(fileLabel, {
			size: 40,
			fill: 0xFFFFFF
		});
		fileText.anchor.set(0.5, 0.5);
		fileText.x = fileX;
		fileText.y = boardOffsetY + 8 * 200 + 60;
		game.addChild(fileText);
	}
}
function createTurnIndicator() {
	// Add turn indicator
	turnText = new Text2('White to move', {
		size: 80,
		fill: 0xFFFFFF
	});
	turnText.anchor.set(0.5, 0);
	turnText.x = 1024;
	turnText.y = 200;
	game.addChild(turnText);
}
// Game starts with main menu - no immediate initialization
game.update = function () {
	// Only update turn indicator if not in menu and turnText exists
	if (gameMode !== 'menu' && turnText) {
		var checkText = '';
		if (isKingInCheck(currentPlayer)) {
			checkText = ' (Check!)';
		}
		var turnDisplay = '';
		if (gameMode === 'computer') {
			if (currentPlayer === playerPerspective) {
				turnDisplay = 'Your turn';
			} else {
				turnDisplay = 'AI thinking...';
			}
		} else {
			turnDisplay = currentPlayer === 'white' ? 'White to move' : 'Black to move';
		}
		turnText.setText(turnDisplay + checkText);
	}
};

===================================================================
--- original.js
+++ change.js
@@ -310,27 +310,114 @@
 var gameOver = false;
 var promotionDialog = null;
 var pendingPromotion = null;
 var playerPerspective = 'white'; // 'white' or 'black' - determines board orientation
-// Initialize board
-for (var row = 0; row < 8; row++) {
-	board[row] = [];
-	squares[row] = [];
-	for (var col = 0; col < 8; col++) {
-		board[row][col] = null;
-		var square = new ChessSquare(row, col);
-		if (playerPerspective === 'black') {
-			// Flip the board for black player perspective
-			square.x = boardOffsetX + (7 - col) * 200 + 100;
-			square.y = boardOffsetY + (7 - row) * 200 + 100;
-		} else {
-			square.x = boardOffsetX + col * 200 + 100;
-			square.y = boardOffsetY + row * 200 + 100;
+var gameMode = 'menu'; // 'menu', 'computer', 'online'
+var isPlayerTurn = true;
+var aiColor = 'black';
+var mainMenu = null;
+function createMainMenu() {
+	mainMenu = new Container();
+	game.addChild(mainMenu);
+	// Title
+	var titleText = new Text2('Chess Game', {
+		size: 120,
+		fill: 0xFFFFFF
+	});
+	titleText.anchor.set(0.5, 0.5);
+	titleText.x = 1024;
+	titleText.y = 600;
+	mainMenu.addChild(titleText);
+	// Computer button
+	var computerButton = new Container();
+	var computerBg = computerButton.attachAsset('promotionDialog', {
+		anchorX: 0.5,
+		anchorY: 0.5,
+		scaleX: 0.8,
+		scaleY: 0.4
+	});
+	var computerText = new Text2('Computer', {
+		size: 80,
+		fill: 0xFFFFFF
+	});
+	computerText.anchor.set(0.5, 0.5);
+	computerButton.addChild(computerText);
+	computerButton.x = 1024;
+	computerButton.y = 900;
+	computerButton.down = function (x, y, obj) {
+		startComputerGame();
+	};
+	mainMenu.addChild(computerButton);
+	// Online button
+	var onlineButton = new Container();
+	var onlineBg = onlineButton.attachAsset('promotionDialog', {
+		anchorX: 0.5,
+		anchorY: 0.5,
+		scaleX: 0.8,
+		scaleY: 0.4
+	});
+	var onlineText = new Text2('Online', {
+		size: 80,
+		fill: 0xFFFFFF
+	});
+	onlineText.anchor.set(0.5, 0.5);
+	onlineButton.addChild(onlineText);
+	onlineButton.x = 1024;
+	onlineButton.y = 1200;
+	onlineButton.down = function (x, y, obj) {
+		startOnlineGame();
+	};
+	mainMenu.addChild(onlineButton);
+}
+function startComputerGame() {
+	gameMode = 'computer';
+	// Randomly assign player color
+	var playerColor = Math.random() < 0.5 ? 'white' : 'black';
+	playerPerspective = playerColor;
+	aiColor = playerColor === 'white' ? 'black' : 'white';
+	isPlayerTurn = currentPlayer === playerColor;
+	// Hide menu and initialize game
+	mainMenu.destroy();
+	mainMenu = null;
+	initializeBoard();
+	initializePieces();
+	addCoordinateLabels();
+	createTurnIndicator();
+}
+function startOnlineGame() {
+	gameMode = 'online';
+	// For now, just start a regular game - online functionality to be implemented later
+	playerPerspective = 'white';
+	mainMenu.destroy();
+	mainMenu = null;
+	initializeBoard();
+	initializePieces();
+	addCoordinateLabels();
+	createTurnIndicator();
+}
+function initializeBoard() {
+	// Initialize board
+	for (var row = 0; row < 8; row++) {
+		board[row] = [];
+		squares[row] = [];
+		for (var col = 0; col < 8; col++) {
+			board[row][col] = null;
+			var square = new ChessSquare(row, col);
+			if (playerPerspective === 'black') {
+				// Flip the board for black player perspective
+				square.x = boardOffsetX + (7 - col) * 200 + 100;
+				square.y = boardOffsetY + (7 - row) * 200 + 100;
+			} else {
+				square.x = boardOffsetX + col * 200 + 100;
+				square.y = boardOffsetY + row * 200 + 100;
+			}
+			squares[row][col] = square;
+			game.addChild(square);
 		}
-		squares[row][col] = square;
-		game.addChild(square);
 	}
 }
+// Show main menu on startup
+createMainMenu();
 // Initialize pieces
 function initializePieces() {
 	// White pieces
 	var whitePieces = [{
@@ -419,8 +506,10 @@
 	}
 }
 function handleSquareClick(row, col) {
 	if (gameOver) return;
+	if (gameMode === 'computer' && !isPlayerTurn) return; // Don't allow moves during AI turn
+	if (gameMode === 'menu') return; // Don't allow moves in menu
 	var clickedPiece = board[row][col];
 	if (selectedPiece) {
 		// Check if clicked square is a valid move
 		var validMove = false;
@@ -439,10 +528,19 @@
 			// Only switch players and check game over if not promoting
 			if (!pendingPromotion) {
 				// Switch players
 				currentPlayer = currentPlayer === 'white' ? 'black' : 'white';
+				if (gameMode === 'computer') {
+					isPlayerTurn = currentPlayer !== aiColor;
+				}
 				// Check for game over conditions
 				checkGameOver();
+				if (gameMode === 'computer' && !isPlayerTurn) {
+					// AI turn - make move after short delay
+					LK.setTimeout(function () {
+						makeAIMove();
+					}, 800);
+				}
 			}
 		} else if (clickedPiece && clickedPiece.color === currentPlayer) {
 			// Select new piece
 			clearHighlights();
@@ -587,8 +685,25 @@
 		}
 	}
 	return allMoves;
 }
+function makeAIMove() {
+	if (gameMode !== 'computer' || currentPlayer !== aiColor || gameOver) return;
+	var validMoves = getValidMovesForPlayer(aiColor);
+	if (validMoves.length === 0) return;
+	// Simple AI: pick a random valid move
+	var randomMove = validMoves[Math.floor(Math.random() * validMoves.length)];
+	movePiece(randomMove.piece, randomMove.row, randomMove.col);
+	// Clear selection and highlights
+	selectedPiece = null;
+	clearHighlights();
+	// Switch players if not promoting
+	if (!pendingPromotion) {
+		currentPlayer = currentPlayer === 'white' ? 'black' : 'white';
+		isPlayerTurn = currentPlayer !== aiColor;
+		checkGameOver();
+	}
+}
 function checkGameOver() {
 	// Find kings
 	var whiteKing = null;
 	var blackKing = null;
@@ -765,72 +880,36 @@
 		fileText.y = boardOffsetY + 8 * 200 + 60;
 		game.addChild(fileText);
 	}
 }
-// Initialize the game
-initializePieces();
-addCoordinateLabels();
-// Example usage: To play as black, call setPlayerPerspective('black')
-// This will flip the board so black pieces are at the bottom
-// Add coordinate labels
-// Add numbers 1-8 on the left side (always from white's perspective)
-for (var i = 0; i < 8; i++) {
-	var rankNumber, rankY;
-	if (playerPerspective === 'black') {
-		// For black player, flip the visual position but keep white's numbering
-		rankNumber = i + 1; // 1 at top, 8 at bottom when flipped
-		rankY = boardOffsetY + i * 200 + 100;
-	} else {
-		rankNumber = 8 - i; // 8 at top, 1 at bottom
-		rankY = boardOffsetY + i * 200 + 100;
-	}
-	var rankText = new Text2(rankNumber.toString(), {
-		size: 40,
+function createTurnIndicator() {
+	// Add turn indicator
+	turnText = new Text2('White to move', {
+		size: 80,
 		fill: 0xFFFFFF
 	});
-	rankText.anchor.set(0.5, 0.5);
-	rankText.x = boardOffsetX - 60; // 60 pixels left of board
-	rankText.y = rankY; // Center of each row
-	game.addChild(rankText);
+	turnText.anchor.set(0.5, 0);
+	turnText.x = 1024;
+	turnText.y = 200;
+	game.addChild(turnText);
 }
-// Add letters a-h (always from white's perspective)
-var files = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'];
-for (var i = 0; i < 8; i++) {
-	var fileLabel, fileX;
-	if (playerPerspective === 'black') {
-		// For black player, flip the visual position but keep white's lettering
-		fileLabel = files[7 - i]; // h to a when flipped
-		fileX = boardOffsetX + i * 200 + 100;
-	} else {
-		fileLabel = files[i]; // a to h
-		fileX = boardOffsetX + i * 200 + 100;
-	}
-	var fileText = new Text2(fileLabel, {
-		size: 40,
-		fill: 0xFFFFFF
-	});
-	fileText.anchor.set(0.5, 0.5);
-	fileText.x = fileX; // Center of each column
-	fileText.y = boardOffsetY + 8 * 200 + 60; // 60 pixels below board
-	game.addChild(fileText);
-}
-// Add turn indicator
-var turnText = new Text2('White to move', {
-	size: 80,
-	fill: 0xFFFFFF
-});
-turnText.anchor.set(0.5, 0);
-turnText.x = 1024;
-turnText.y = 200;
-game.addChild(turnText);
+// Game starts with main menu - no immediate initialization
 game.update = function () {
-	// Update turn indicator
-	var checkText = '';
-	if (isKingInCheck(currentPlayer)) {
-		checkText = ' (Check!)';
+	// Only update turn indicator if not in menu and turnText exists
+	if (gameMode !== 'menu' && turnText) {
+		var checkText = '';
+		if (isKingInCheck(currentPlayer)) {
+			checkText = ' (Check!)';
+		}
+		var turnDisplay = '';
+		if (gameMode === 'computer') {
+			if (currentPlayer === playerPerspective) {
+				turnDisplay = 'Your turn';
+			} else {
+				turnDisplay = 'AI thinking...';
+			}
+		} else {
+			turnDisplay = currentPlayer === 'white' ? 'White to move' : 'Black to move';
+		}
+		turnText.setText(turnDisplay + checkText);
 	}
-	if (currentPlayer === 'white') {
-		turnText.setText('White to move' + checkText);
-	} else {
-		turnText.setText('Black to move' + checkText);
-	}
 };
\ No newline at end of file