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

/**** 
* Classes
****/ 
var ChessBoard = Container.expand(function () {
	var self = Container.call(this);
	self.squares = [];
	self.pieces = {};
	self.selectedPiece = null;
	self.validMoves = [];
	self.whiteKingPos = {
		row: 7,
		col: 4
	};
	self.blackKingPos = {
		row: 0,
		col: 4
	};
	var BOARD_SIZE = 8;
	var SQUARE_SIZE = 128;
	self.initBoard = function () {
		// Create board squares
		for (var row = 0; row < BOARD_SIZE; row++) {
			self.squares[row] = [];
			for (var col = 0; col < BOARD_SIZE; col++) {
				var isDark = (row + col) % 2 === 1;
				var square = self.addChild(LK.getAsset(isDark ? 'boardSquareDark' : 'boardSquare', {
					anchorX: 0.5,
					anchorY: 0.5,
					x: col * SQUARE_SIZE + SQUARE_SIZE / 2,
					y: row * SQUARE_SIZE + SQUARE_SIZE / 2
				}));
				square.row = row;
				square.col = col;
				square.isEmpty = true;
				self.squares[row][col] = square;
			}
		}
		// Set up pieces
		self.setupPieces();
	};
	self.setupPieces = function () {
		var startPosition = {
			0: ['rook', 'knight', 'bishop', 'queen', 'king', 'bishop', 'knight', 'rook'],
			1: ['pawn', 'pawn', 'pawn', 'pawn', 'pawn', 'pawn', 'pawn', 'pawn'],
			6: ['pawn', 'pawn', 'pawn', 'pawn', 'pawn', 'pawn', 'pawn', 'pawn'],
			7: ['rook', 'knight', 'bishop', 'queen', 'king', 'bishop', 'knight', 'rook']
		};
		for (var row in startPosition) {
			row = parseInt(row);
			for (var col = 0; col < startPosition[row].length; col++) {
				var color = row < 2 ? 'black' : 'white';
				var type = startPosition[row][col];
				self.addPiece(type, color, row, col);
			}
		}
	};
	self.addPiece = function (type, color, row, col) {
		var piece = new ChessPiece();
		piece.type = type;
		piece.setColor(color);
		piece.setText(piece.getSymbol());
		piece.row = row;
		piece.col = col;
		var square = self.squares[row][col];
		piece.x = square.x;
		piece.y = square.y;
		self.addChild(piece);
		self.pieces[row + '-' + col] = piece;
		square.isEmpty = false;
	};
	self.getPiece = function (row, col) {
		return self.pieces[row + '-' + col] || null;
	};
	self.removePiece = function (row, col) {
		var piece = self.getPiece(row, col);
		if (piece) {
			piece.destroy();
			delete self.pieces[row + '-' + col];
			self.squares[row][col].isEmpty = true;
		}
	};
	self.getValidMoves = function (piece) {
		var moves = [];
		if (piece.type === 'pawn') {
			moves = self.getPawnMoves(piece);
		} else if (piece.type === 'rook') {
			moves = self.getRookMoves(piece);
		} else if (piece.type === 'knight') {
			moves = self.getKnightMoves(piece);
		} else if (piece.type === 'bishop') {
			moves = self.getBishopMoves(piece);
		} else if (piece.type === 'queen') {
			moves = self.getQueenMoves(piece);
		} else if (piece.type === 'king') {
			moves = self.getKingMoves(piece);
		}
		return self.filterLegalMoves(piece, moves);
	};
	self.getPawnMoves = function (piece) {
		var moves = [];
		var direction = piece.color === 'white' ? -1 : 1;
		var startRow = piece.color === 'white' ? 6 : 1;
		var nextRow = piece.row + direction;
		if (nextRow >= 0 && nextRow < 8) {
			if (!self.getPiece(nextRow, piece.col)) {
				moves.push({
					row: nextRow,
					col: piece.col
				});
				// Double move from start
				if (piece.row === startRow) {
					var doubleRow = piece.row + 2 * direction;
					if (!self.getPiece(doubleRow, piece.col)) {
						moves.push({
							row: doubleRow,
							col: piece.col
						});
					}
				}
			}
			// Captures
			if (piece.col > 0) {
				var captureLeft = self.getPiece(nextRow, piece.col - 1);
				if (captureLeft && captureLeft.color !== piece.color) {
					moves.push({
						row: nextRow,
						col: piece.col - 1
					});
				}
			}
			if (piece.col < 7) {
				var captureRight = self.getPiece(nextRow, piece.col + 1);
				if (captureRight && captureRight.color !== piece.color) {
					moves.push({
						row: nextRow,
						col: piece.col + 1
					});
				}
			}
		}
		return moves;
	};
	self.getRookMoves = function (piece) {
		var moves = [];
		var directions = [[-1, 0], [1, 0], [0, -1], [0, 1]];
		for (var d = 0; d < directions.length; d++) {
			var dr = directions[d][0];
			var dc = directions[d][1];
			for (var i = 1; i < 8; i++) {
				var newRow = piece.row + dr * i;
				var newCol = piece.col + dc * i;
				if (newRow < 0 || newRow >= 8 || newCol < 0 || newCol >= 8) break;
				var target = self.getPiece(newRow, newCol);
				if (!target) {
					moves.push({
						row: newRow,
						col: newCol
					});
				} else {
					if (target.color !== piece.color) {
						moves.push({
							row: newRow,
							col: newCol
						});
					}
					break;
				}
			}
		}
		return moves;
	};
	self.getKnightMoves = function (piece) {
		var moves = [];
		var offsets = [[-2, -1], [-2, 1], [-1, -2], [-1, 2], [1, -2], [1, 2], [2, -1], [2, 1]];
		for (var i = 0; i < offsets.length; i++) {
			var newRow = piece.row + offsets[i][0];
			var newCol = piece.col + offsets[i][1];
			if (newRow >= 0 && newRow < 8 && newCol >= 0 && newCol < 8) {
				var target = self.getPiece(newRow, newCol);
				if (!target || target.color !== piece.color) {
					moves.push({
						row: newRow,
						col: newCol
					});
				}
			}
		}
		return moves;
	};
	self.getBishopMoves = function (piece) {
		var moves = [];
		var directions = [[-1, -1], [-1, 1], [1, -1], [1, 1]];
		for (var d = 0; d < directions.length; d++) {
			var dr = directions[d][0];
			var dc = directions[d][1];
			for (var i = 1; i < 8; i++) {
				var newRow = piece.row + dr * i;
				var newCol = piece.col + dc * i;
				if (newRow < 0 || newRow >= 8 || newCol < 0 || newCol >= 8) break;
				var target = self.getPiece(newRow, newCol);
				if (!target) {
					moves.push({
						row: newRow,
						col: newCol
					});
				} else {
					if (target.color !== piece.color) {
						moves.push({
							row: newRow,
							col: newCol
						});
					}
					break;
				}
			}
		}
		return moves;
	};
	self.getQueenMoves = function (piece) {
		var rookMoves = self.getRookMoves(piece);
		var bishopMoves = self.getBishopMoves(piece);
		return rookMoves.concat(bishopMoves);
	};
	self.getKingMoves = function (piece) {
		var moves = [];
		for (var dr = -1; dr <= 1; dr++) {
			for (var dc = -1; dc <= 1; dc++) {
				if (dr === 0 && dc === 0) continue;
				var newRow = piece.row + dr;
				var newCol = piece.col + dc;
				if (newRow >= 0 && newRow < 8 && newCol >= 0 && newCol < 8) {
					var target = self.getPiece(newRow, newCol);
					if (!target || target.color !== piece.color) {
						moves.push({
							row: newRow,
							col: newCol
						});
					}
				}
			}
		}
		return moves;
	};
	self.filterLegalMoves = function (piece, moves) {
		return moves; // Simplified for MVP - full check detection would go here
	};
	self.movePiece = function (fromRow, fromCol, toRow, toCol) {
		var piece = self.getPiece(fromRow, fromCol);
		if (!piece) return false;
		// Check if destination has enemy piece
		var capturedPiece = self.getPiece(toRow, toCol);
		if (capturedPiece) {
			self.removePiece(toRow, toCol);
			LK.getSound('capture').play();
		} else {
			LK.getSound('movePiece').play();
		}
		// Move piece
		delete self.pieces[fromRow + '-' + fromCol];
		self.squares[fromRow][fromCol].isEmpty = true;
		piece.row = toRow;
		piece.col = toCol;
		piece.hasMoved = true;
		var square = self.squares[toRow][toCol];
		piece.x = square.x;
		piece.y = square.y;
		self.pieces[toRow + '-' + toCol] = piece;
		self.squares[toRow][toCol].isEmpty = false;
		// Update king positions
		if (piece.type === 'king') {
			if (piece.color === 'white') {
				self.whiteKingPos = {
					row: toRow,
					col: toCol
				};
			} else {
				self.blackKingPos = {
					row: toRow,
					col: toCol
				};
			}
		}
		return true;
	};
	self.isInCheck = function (color) {
		var kingPos = color === 'white' ? self.whiteKingPos : self.blackKingPos;
		var king = self.getPiece(kingPos.row, kingPos.col);
		if (!king) return false;
		// Check if any enemy piece can attack the king
		for (var row = 0; row < 8; row++) {
			for (var col = 0; col < 8; col++) {
				var piece = self.getPiece(row, col);
				if (piece && piece.color !== color) {
					var moves = self.getValidMoves(piece);
					for (var i = 0; i < moves.length; i++) {
						if (moves[i].row === kingPos.row && moves[i].col === kingPos.col) {
							return true;
						}
					}
				}
			}
		}
		return false;
	};
	self.isCheckmate = function (color) {
		if (!self.isInCheck(color)) return false;
		// Check if any legal move exists
		for (var row = 0; row < 8; row++) {
			for (var col = 0; col < 8; col++) {
				var piece = self.getPiece(row, col);
				if (piece && piece.color === color) {
					var moves = self.getValidMoves(piece);
					if (moves.length > 0) {
						return false;
					}
				}
			}
		}
		return true;
	};
	self.clearHighlights = function () {
		if (self.selectedHighlight) {
			self.selectedHighlight.destroy();
			self.selectedHighlight = null;
		}
		for (var i = 0; i < self.validMoves.length; i++) {
			self.validMoves[i].destroy();
		}
		self.validMoves = [];
	};
	self.showMoveHighlights = function (moves) {
		self.clearHighlights();
		for (var i = 0; i < moves.length; i++) {
			var move = moves[i];
			var square = self.squares[move.row][move.col];
			var highlight = self.addChild(LK.getAsset('moveHighlight', {
				anchorX: 0.5,
				anchorY: 0.5,
				x: square.x,
				y: square.y
			}));
			self.validMoves.push(highlight);
		}
	};
	self.initBoard();
	return self;
});
var ChessPiece = Container.expand(function () {
	var self = Container.call(this);
	self.type = 'pawn'; // pawn, rook, knight, bishop, queen, king
	self.color = 'white'; // white or black
	self.row = 0;
	self.col = 0;
	self.hasMoved = false;
	var graphics = self.attachAsset('piece', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.setText = function (text) {
		if (!self.label) {
			self.label = new Text2(text, {
				size: 60,
				fill: '#000000'
			});
			self.label.anchor.set(0.5, 0.5);
			self.addChild(self.label);
		} else {
			self.label.setText(text);
		}
	};
	self.setColor = function (color) {
		self.color = color;
		if (color === 'black') {
			graphics.tint = 0x333333;
		} else {
			graphics.tint = 0xFFFFFF;
		}
	};
	self.getSymbol = function () {
		var symbols = {
			'pawn': '♟',
			'rook': '♜',
			'knight': '♞',
			'bishop': '♝',
			'queen': '♛',
			'king': '♚'
		};
		return symbols[self.type] || '●';
	};
	return self;
});
var FriendListScreen = Container.expand(function () {
	var self = Container.call(this);
	self.init = function () {
		var title = new Text2('Invite Friends', {
			size: 100,
			fill: '#FFD700'
		});
		title.anchor.set(0.5, 0.5);
		title.x = 1024;
		title.y = 150;
		self.addChild(title);
		var friendsList = storage.friends || [];
		var inviteCode = 'CHESS' + Math.floor(Math.random() * 100000);
		var codeDisplay = new Text2('Your Code: ' + inviteCode, {
			size: 60,
			fill: '#00FF00'
		});
		codeDisplay.anchor.set(0.5, 0.5);
		codeDisplay.x = 1024;
		codeDisplay.y = 300;
		self.addChild(codeDisplay);
		var friendsTitle = new Text2('Friends (' + friendsList.length + ')', {
			size: 70,
			fill: '#FFD700'
		});
		friendsTitle.anchor.set(0.5, 0.5);
		friendsTitle.x = 1024;
		friendsTitle.y = 450;
		self.addChild(friendsTitle);
		for (var f = 0; f < friendsList.length; f++) {
			var friendBox = self.addChild(LK.getAsset('difficultyButton', {
				anchorX: 0.5,
				anchorY: 0.5,
				x: 1024,
				y: 600 + f * 250
			}));
			var friendText = new Text2(friendsList[f], {
				size: 50,
				fill: '#FFFFFF'
			});
			friendText.anchor.set(0.5, 0.5);
			friendBox.addChild(friendText);
			tween(friendBox, {
				scaleX: 1.05,
				scaleY: 1.05
			}, {
				duration: 300,
				easing: tween.easeInOut
			});
		}
		var backBtn = self.addChild(LK.getAsset('button', {
			anchorX: 0.5,
			anchorY: 0.5,
			x: 1024,
			y: 2550
		}));
		var backBtnText = new Text2('Back', {
			size: 50,
			fill: '#FFFFFF'
		});
		backBtnText.anchor.set(0.5, 0.5);
		backBtn.addChild(backBtnText);
	};
	return self;
});
var GameScreen = Container.expand(function () {
	var self = Container.call(this);
	self.board = null;
	self.currentPlayer = 'white';
	self.difficulty = 'intermediate';
	self.gameOver = false;
	self.selectedPiece = null;
	self.init = function (difficulty, gameMode, opponent) {
		self.difficulty = difficulty;
		self.gameMode = gameMode || 'singleplayer';
		self.opponent = opponent || 'AI';
		self.currentPlayer = 'white';
		self.gameOver = false;
		self.selectedPiece = null;
		self.moveCount = 0;
		self.capturedPieces = 0;
		self.startTime = Date.now();
		// Create board
		self.board = self.addChild(new ChessBoard());
		self.board.x = (2048 - 1024) / 2;
		self.board.y = 300;
		// Create status text
		self.statusText = new Text2('White to move', {
			size: 80,
			fill: '#FFFFFF'
		});
		self.statusText.anchor.set(0.5, 0.5);
		self.statusText.x = 1024;
		self.statusText.y = 100;
		self.addChild(self.statusText);
		// Create score display
		self.scoreText = new Text2('Moves: 0 | Captured: 0', {
			size: 50,
			fill: '#FFFF00'
		});
		self.scoreText.anchor.set(0.5, 0.5);
		self.scoreText.x = 1024;
		self.scoreText.y = 180;
		self.addChild(self.scoreText);
		// Create back button
		self.backButton = self.addChild(LK.getAsset('button', {
			anchorX: 0.5,
			anchorY: 0.5,
			x: 1024,
			y: 2600
		}));
		var backButtonText = new Text2('Back to Menu', {
			size: 50,
			fill: '#FFFFFF'
		});
		backButtonText.anchor.set(0.5, 0.5);
		self.backButton.addChild(backButtonText);
	};
	self.selectSquare = function (x, y) {
		if (self.gameOver || self.currentPlayer === 'black') return;
		// Find which square was clicked
		var boardX = x - self.board.x;
		var boardY = y - self.board.y;
		var col = Math.floor(boardX / 128);
		var row = Math.floor(boardY / 128);
		if (row < 0 || row >= 8 || col < 0 || col >= 8) return;
		var piece = self.board.getPiece(row, col);
		// If a piece is selected and clicking on a different square
		if (self.selectedPiece && (self.selectedPiece.row !== row || self.selectedPiece.col !== col)) {
			// Check if clicked square is a valid move
			var validMoves = self.board.getValidMoves(self.selectedPiece);
			var isValidMove = false;
			for (var i = 0; i < validMoves.length; i++) {
				if (validMoves[i].row === row && validMoves[i].col === col) {
					isValidMove = true;
					break;
				}
			}
			if (isValidMove) {
				var capturedPiece = self.board.getPiece(row, col);
				if (capturedPiece) {
					self.capturedPieces += 1;
				}
				self.board.movePiece(self.selectedPiece.row, self.selectedPiece.col, row, col);
				self.moveCount += 1;
				self.scoreText.setText('Moves: ' + self.moveCount + ' | Captured: ' + self.capturedPieces);
				self.board.clearHighlights();
				self.selectedPiece = null;
				// Check for checkmate
				if (self.board.isCheckmate('black')) {
					self.gameOver = true;
					self.statusText.setText('Checkmate! White wins!');
					LK.getSound('checkmate').play();
					LK.getSound('victory').play();
				} else {
					self.currentPlayer = 'black';
					self.statusText.setText('Black to move');
					// AI move after delay
					LK.setTimeout(function () {
						self.makeAIMove();
					}, 1000);
				}
			}
		} else if (piece && piece.color === 'white') {
			// Select a new piece
			self.selectedPiece = piece;
			var moves = self.board.getValidMoves(piece);
			self.board.showMoveHighlights(moves);
		}
	};
	self.makeAIMove = function () {
		if (self.gameOver) return;
		// Get all possible moves for black
		var allMoves = [];
		for (var row = 0; row < 8; row++) {
			for (var col = 0; col < 8; col++) {
				var piece = self.board.getPiece(row, col);
				if (piece && piece.color === 'black') {
					var moves = self.board.getValidMoves(piece);
					for (var i = 0; i < moves.length; i++) {
						allMoves.push({
							piece: piece,
							from: {
								row: piece.row,
								col: piece.col
							},
							to: moves[i]
						});
					}
				}
			}
		}
		if (allMoves.length === 0) {
			self.gameOver = true;
			self.statusText.setText('Stalemate!');
			return;
		}
		// Select move based on difficulty
		var selectedMove;
		if (self.difficulty === 'beginner') {
			selectedMove = allMoves[Math.floor(Math.random() * allMoves.length)];
		} else if (self.difficulty === 'intermediate') {
			// Prefer captures
			var captureMoves = allMoves.filter(function (m) {
				return self.board.getPiece(m.to.row, m.to.col) !== null;
			});
			selectedMove = captureMoves.length > 0 ? captureMoves[Math.floor(Math.random() * captureMoves.length)] : allMoves[Math.floor(Math.random() * allMoves.length)];
		} else {
			// Advanced/Master: Prefer captures and center control
			var scoredMoves = allMoves.map(function (m) {
				var score = 0;
				if (self.board.getPiece(m.to.row, m.to.col)) score += 100;
				var distFromCenter = Math.abs(m.to.row - 3.5) + Math.abs(m.to.col - 3.5);
				score += (7 - distFromCenter) * 10;
				return {
					move: m,
					score: score
				};
			});
			scoredMoves.sort(function (a, b) {
				return b.score - a.score;
			});
			selectedMove = scoredMoves[0].move;
		}
		var capturedPiece = self.board.getPiece(selectedMove.to.row, selectedMove.to.col);
		if (capturedPiece) {
			self.capturedPieces += 1;
		}
		self.moveCount += 1;
		self.scoreText.setText('Moves: ' + self.moveCount + ' | Captured: ' + self.capturedPieces);
		self.board.movePiece(selectedMove.from.row, selectedMove.from.col, selectedMove.to.row, selectedMove.to.col);
		self.board.clearHighlights();
		// Check for checkmate
		if (self.board.isCheckmate('white')) {
			self.gameOver = true;
			self.statusText.setText('Checkmate! Black wins!');
			LK.getSound('checkmate').play();
		} else {
			self.currentPlayer = 'white';
			self.statusText.setText('White to move');
		}
	};
	return self;
});
var MenuScreen = Container.expand(function () {
	var self = Container.call(this);
	self.init = function () {
		// Title
		var title = new Text2('Chess Master', {
			size: 120,
			fill: '#FFD700'
		});
		title.anchor.set(0.5, 0.5);
		title.x = 1024;
		title.y = 200;
		self.addChild(title);
		// Trophy/Cup Display
		var cupDisplay = new Text2('Cups: ' + (storage.totalCups || 0), {
			size: 80,
			fill: '#FFFFFF'
		});
		cupDisplay.anchor.set(0.5, 0.5);
		cupDisplay.x = 1024;
		cupDisplay.y = 350;
		self.addChild(cupDisplay);
		// Trophy Road
		var trophyTitle = new Text2('Trophy Road', {
			size: 70,
			fill: '#FFD700'
		});
		trophyTitle.anchor.set(0.5, 0.5);
		trophyTitle.x = 1024;
		trophyTitle.y = 500;
		self.addChild(trophyTitle);
		// Display trophy milestones with enhanced animations
		var milestones = [5, 10, 20, 50];
		var currentCups = storage.totalCups || 0;
		for (var i = 0; i < milestones.length; i++) {
			var xPos = 300 + i * 450;
			var milestone = milestones[i];
			var isUnlocked = currentCups >= milestone;
			var trophy = self.addChild(LK.getAsset('trophy', {
				anchorX: 0.5,
				anchorY: 0.5,
				x: xPos,
				y: 650,
				scaleX: isUnlocked ? 1.2 : 0.8,
				scaleY: isUnlocked ? 1.2 : 0.8
			}));
			if (!isUnlocked) {
				trophy.tint = 0x808080;
			} else {
				tween(trophy, {
					scaleX: 1.3,
					scaleY: 1.3
				}, {
					duration: 500,
					easing: tween.elasticOut
				});
			}
			var label = new Text2(milestone + ' Cups', {
				size: 40,
				fill: isUnlocked ? '#FFD700' : '#CCCCCC'
			});
			label.anchor.set(0.5, 0.5);
			label.x = xPos;
			label.y = 800;
			self.addChild(label);
		}
		// Game mode selection
		var modeTitle = new Text2('Game Mode', {
			size: 70,
			fill: '#FFD700'
		});
		modeTitle.anchor.set(0.5, 0.5);
		modeTitle.x = 1024;
		modeTitle.y = 1050;
		self.addChild(modeTitle);
		var modes = ['Single Player', 'Two Player', 'Challenges'];
		var modeButtonSpacing = 500;
		var modeStartX = 250;
		for (var m = 0; m < modes.length; m++) {
			var modeButton = self.addChild(LK.getAsset('difficultyButton', {
				anchorX: 0.5,
				anchorY: 0.5,
				x: modeStartX + m * modeButtonSpacing,
				y: 1200
			}));
			var modeButtonText = new Text2(modes[m], {
				size: 45,
				fill: '#FFFFFF'
			});
			modeButtonText.anchor.set(0.5, 0.5);
			modeButton.addChild(modeButtonText);
			modeButton.gameMode = modes[m].toLowerCase().replace(' ', '');
		}
		// Invite Friends button
		var inviteButton = self.addChild(LK.getAsset('difficultyButton', {
			anchorX: 0.5,
			anchorY: 0.5,
			x: 1024,
			y: 1600
		}));
		var inviteButtonText = new Text2('👥 Invite Friends', {
			size: 50,
			fill: '#FFFFFF'
		});
		inviteButtonText.anchor.set(0.5, 0.5);
		inviteButton.addChild(inviteButtonText);
		inviteButton.isFriendButton = true;
		// Difficulty buttons for single player
		var difficulties = ['Beginner', 'Intermediate', 'Advanced', 'Master'];
		var buttonSpacing = 450;
		var startX = 300;
		for (var i = 0; i < difficulties.length; i++) {
			var button = self.addChild(LK.getAsset('difficultyButton', {
				anchorX: 0.5,
				anchorY: 0.5,
				x: startX + i * buttonSpacing,
				y: 1400
			}));
			var buttonText = new Text2(difficulties[i], {
				size: 50,
				fill: '#FFFFFF'
			});
			buttonText.anchor.set(0.5, 0.5);
			button.addChild(buttonText);
			button.difficulty = difficulties[i].toLowerCase();
			button.gameMode = 'singleplayer';
		}
	};
	return self;
});

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

/**** 
* Game Code
****/ 
// Initialize storage
if (!storage.totalCups) {
	storage.totalCups = 0;
}
if (!storage.friends) {
	storage.friends = [];
}
if (!storage.gameScores) {
	storage.gameScores = [];
}
if (!storage.totalWins) {
	storage.totalWins = 0;
}
if (!storage.totalLosses) {
	storage.totalLosses = 0;
}
if (!storage.activeChallenges) {
	storage.activeChallenges = [];
}
var currentScreen = null;
var gameScreen = null;
function showMenu() {
	if (currentScreen) {
		currentScreen.destroy();
	}
	currentScreen = game.addChild(new MenuScreen());
	currentScreen.init();
	LK.playMusic('chessMusic', {
		loop: true
	});
}
function startGame(difficulty, gameMode, opponent) {
	if (currentScreen) {
		currentScreen.destroy();
	}
	gameScreen = game.addChild(new GameScreen());
	gameScreen.init(difficulty, gameMode, opponent);
	currentScreen = gameScreen;
}
function showFriendScreen() {
	if (currentScreen) {
		currentScreen.destroy();
	}
	currentScreen = game.addChild(new FriendListScreen());
	currentScreen.init();
}
function showChallengeScreen() {
	if (currentScreen) {
		currentScreen.destroy();
	}
	var challengeScreen = game.addChild(new Container());
	var title = new Text2('Challenges', {
		size: 100,
		fill: '#FFD700'
	});
	title.anchor.set(0.5, 0.5);
	title.x = 1024;
	title.y = 150;
	challengeScreen.addChild(title);
	var challenges = [{
		name: 'Rapid Win',
		description: 'Win in 15 moves',
		difficulty: 'intermediate'
	}, {
		name: 'Master Hunt',
		description: 'Beat Master AI',
		difficulty: 'master'
	}, {
		name: 'Preservation',
		description: 'Capture 5+ pieces',
		difficulty: 'advanced'
	}];
	for (var c = 0; c < challenges.length; c++) {
		var yPos = 400 + c * 400;
		var challengeBox = challengeScreen.addChild(LK.getAsset('difficultyButton', {
			anchorX: 0.5,
			anchorY: 0.5,
			x: 1024,
			y: yPos
		}));
		var chalText = new Text2(challenges[c].name + ': ' + challenges[c].description, {
			size: 45,
			fill: '#FFFFFF'
		});
		chalText.anchor.set(0.5, 0.5);
		challengeBox.addChild(chalText);
		challengeBox.challengeData = challenges[c];
	}
	var backBtn = challengeScreen.addChild(LK.getAsset('button', {
		anchorX: 0.5,
		anchorY: 0.5,
		x: 1024,
		y: 2550
	}));
	var backBtnText = new Text2('Back', {
		size: 50,
		fill: '#FFFFFF'
	});
	backBtnText.anchor.set(0.5, 0.5);
	backBtn.addChild(backBtnText);
	currentScreen = challengeScreen;
}
function endGame(playerWon) {
	var gameScore = {
		timestamp: Date.now(),
		gameMode: gameScreen.gameMode,
		opponent: gameScreen.opponent,
		difficulty: gameScreen.difficulty,
		won: playerWon,
		moves: gameScreen.moveCount,
		capturedPieces: gameScreen.capturedPieces,
		duration: Date.now() - gameScreen.startTime
	};
	storage.gameScores.push(gameScore);
	if (playerWon) {
		storage.totalWins = (storage.totalWins || 0) + 1;
		var cupRewards = {
			'beginner': 1,
			'intermediate': 2,
			'advanced': 5,
			'master': 10
		};
		var reward = cupRewards[gameScreen.difficulty] || 1;
		storage.totalCups = (storage.totalCups || 0) + reward;
		LK.setScore(storage.totalCups);
	} else {
		storage.totalLosses = (storage.totalLosses || 0) + 1;
	}
	LK.setTimeout(function () {
		showMenu();
	}, 3000);
}
// Initialize game with menu
showMenu();
// Handle game interactions
game.down = function (x, y, obj) {
	if (currentScreen === gameScreen) {
		gameScreen.selectSquare(x, y);
	} else if (currentScreen === menuScreen) {
		// Check if button was clicked (difficulty or game mode)
		for (var i = 0; i < currentScreen.children.length; i++) {
			var child = currentScreen.children[i];
			if ((child.difficulty || child.gameMode || child.isFriendButton) && child.intersects) {
				var globalPos = child.parent.toGlobal(child.position);
				var localPos = game.toLocal(globalPos);
				if (x >= localPos.x - child.width / 2 && x <= localPos.x + child.width / 2 && y >= localPos.y - child.height / 2 && y <= localPos.y + child.height / 2) {
					tween(child, {
						scaleX: 0.95,
						scaleY: 0.95
					}, {
						duration: 100
					});
					if (child.isFriendButton) {
						showFriendScreen();
					} else if (child.gameMode === 'twoplayer') {
						startGame('intermediate', 'twoplayer', 'player2');
					} else if (child.gameMode === 'challenges') {
						showChallengeScreen();
					} else if (child.difficulty) {
						startGame(child.difficulty, 'singleplayer', 'AI');
					}
					return;
				}
			}
		}
	} else {
		// Challenge screen or other screens
		for (var j = 0; j < currentScreen.children.length; j++) {
			var elem = currentScreen.children[j];
			if (elem.challengeData && elem.intersects) {
				var gPos = elem.parent.toGlobal(elem.position);
				var lPos = game.toLocal(gPos);
				if (x >= lPos.x - elem.width / 2 && x <= lPos.x + elem.width / 2 && y >= lPos.y - elem.height / 2 && y <= lPos.y + elem.height / 2) {
					startGame(elem.challengeData.difficulty, 'challenge', 'AI');
					return;
				}
			}
		}
	}
};
// Check if back button was clicked
game.move = function (x, y, obj) {
	// Movement tracking for future UI interactions
};
game.up = function (x, y, obj) {
	if (currentScreen === gameScreen && gameScreen.backButton) {
		var backGlobalPos = gameScreen.backButton.parent.toGlobal(gameScreen.backButton.position);
		var backLocalPos = game.toLocal(backGlobalPos);
		if (x >= backLocalPos.x - gameScreen.backButton.width / 2 && x <= backLocalPos.x + gameScreen.backButton.width / 2 && y >= backLocalPos.y - gameScreen.backButton.height / 2 && y <= backLocalPos.y + gameScreen.backButton.height / 2) {
			if (gameScreen.gameOver) {
				endGame(gameScreen.statusText.text.indexOf('White wins') !== -1);
			} else {
				showMenu();
			}
		}
	} else if (currentScreen !== gameScreen) {
		// Check for back button in other screens
		for (var k = 0; k < currentScreen.children.length; k++) {
			var backElem = currentScreen.children[k];
			if (backElem.intersects && currentScreen.children.indexOf(backElem) === currentScreen.children.length - 1) {
				var bGPos = backElem.parent.toGlobal(backElem.position);
				var bLPos = game.toLocal(bGPos);
				if (x >= bLPos.x - backElem.width / 2 && x <= bLPos.x + backElem.width / 2 && y >= bLPos.y - backElem.height / 2 && y <= bLPos.y + backElem.height / 2) {
					showMenu();
					return;
				}
			}
		}
	}
};
var menuScreen = currentScreen;
game.update = function () {
	// Game update logic
	if (gameScreen && !gameScreen.gameOver) {
		// Check for game state changes
	}
};

===================================================================
--- original.js
+++ change.js
@@ -817,8 +817,15 @@
 	gameScreen = game.addChild(new GameScreen());
 	gameScreen.init(difficulty, gameMode, opponent);
 	currentScreen = gameScreen;
 }
+function showFriendScreen() {
+	if (currentScreen) {
+		currentScreen.destroy();
+	}
+	currentScreen = game.addChild(new FriendListScreen());
+	currentScreen.init();
+}
 function showChallengeScreen() {
 	if (currentScreen) {
 		currentScreen.destroy();
 	}