===================================================================
--- original.js
+++ change.js
@@ -1,6 +1,802 @@
-/****
+/**** 
+* 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;
+});
+
+/**** 
 * Initialize Game
-****/
+****/ 
 var game = new LK.Game({
-	backgroundColor: 0x000000
-});
\ No newline at end of file
+	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 = 'playing'; // 'playing', 'check', 'checkmate', 'stalemate'
+var aiThinking = false;
+// 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('Chess Master', {
+	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 () {
+	// 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');
+	}
+};
+// Initialize the game
+initializeBoard();
\ No newline at end of file