===================================================================
--- original.js
+++ change.js
@@ -1,6 +1,467 @@
-/****
+/**** 
+* Plugins
+****/ 
+var tween = LK.import("@upit/tween.v1");
+
+/**** 
+* Classes
+****/ 
+var ChessBoard = Container.expand(function () {
+	var self = Container.call(this);
+	self.squares = [];
+	self.highlightSquares = [];
+	// Create board squares
+	for (var row = 0; row < 8; row++) {
+		self.squares[row] = [];
+		for (var col = 0; col < 8; col++) {
+			var isLight = (row + col) % 2 === 1;
+			var square = self.attachAsset(isLight ? 'lightSquare' : 'darkSquare', {
+				x: col * squareSize,
+				y: row * squareSize
+			});
+			self.squares[row][col] = square;
+		}
+	}
+	self.clearHighlights = function () {
+		for (var i = 0; i < self.highlightSquares.length; i++) {
+			self.highlightSquares[i].destroy();
+		}
+		self.highlightSquares = [];
+	};
+	self.highlightSquare = function (row, col, type) {
+		var assetType = type || 'selectedSquare';
+		var highlight = self.attachAsset(assetType, {
+			x: col * squareSize,
+			y: row * squareSize,
+			alpha: 0.7
+		});
+		self.highlightSquares.push(highlight);
+	};
+	return self;
+});
+var ChessPiece = Container.expand(function (pieceType, color, row, col) {
+	var self = Container.call(this);
+	self.pieceType = pieceType;
+	self.color = color;
+	self.row = row;
+	self.col = col;
+	self.hasMoved = false;
+	var assetId = color + pieceType;
+	var pieceGraphics = self.attachAsset(assetId, {
+		anchorX: 0.5,
+		anchorY: 0.5
+	});
+	self.moveTo = function (newRow, newCol) {
+		self.row = newRow;
+		self.col = newCol;
+		self.hasMoved = true;
+		self.x = boardOffsetX + newCol * squareSize + squareSize / 2;
+		self.y = boardOffsetY + newRow * squareSize + squareSize / 2;
+	};
+	self.getValidMoves = function () {
+		var moves = [];
+		switch (self.pieceType) {
+			case 'Pawn':
+				moves = getPawnMoves(self);
+				break;
+			case 'Rook':
+				moves = getRookMoves(self);
+				break;
+			case 'Knight':
+				moves = getKnightMoves(self);
+				break;
+			case 'Bishop':
+				moves = getBishopMoves(self);
+				break;
+			case 'Queen':
+				moves = getQueenMoves(self);
+				break;
+			case 'King':
+				moves = getKingMoves(self);
+				break;
+		}
+		return moves;
+	};
+	return self;
+});
+
+/**** 
 * Initialize Game
-****/
+****/ 
 var game = new LK.Game({
-	backgroundColor: 0x000000
-});
\ No newline at end of file
+	backgroundColor: 0x8B7355
+});
+
+/**** 
+* Game Code
+****/ 
+// Black pieces
+// White pieces
+var squareSize = 128;
+var boardSize = squareSize * 8;
+var boardOffsetX = (2048 - boardSize) / 2;
+var boardOffsetY = (2732 - boardSize) / 2 - 200;
+var board = game.addChild(new ChessBoard());
+board.x = boardOffsetX;
+board.y = boardOffsetY;
+var pieces = [];
+var gameBoard = [];
+var currentTurn = 'white';
+var selectedPiece = null;
+var whiteKing = null;
+var blackKing = null;
+var gameOver = false;
+// Initialize game board array
+for (var row = 0; row < 8; row++) {
+	gameBoard[row] = [];
+	for (var col = 0; col < 8; col++) {
+		gameBoard[row][col] = null;
+	}
+}
+// Create turn indicator
+var turnText = new Text2('White\'s Turn', {
+	size: 80,
+	fill: 0xFFFFFF
+});
+turnText.anchor.set(0.5, 0);
+LK.gui.top.addChild(turnText);
+turnText.y = 150;
+// Setup initial piece positions
+function setupPieces() {
+	var initialSetup = [['Rook', 'Knight', 'Bishop', 'Queen', 'King', 'Bishop', 'Knight', 'Rook'], ['Pawn', 'Pawn', 'Pawn', 'Pawn', 'Pawn', 'Pawn', 'Pawn', 'Pawn']];
+	// Black pieces
+	for (var row = 0; row < 2; row++) {
+		for (var col = 0; col < 8; col++) {
+			var piece = new ChessPiece(initialSetup[row][col], 'black', row, col);
+			piece.x = boardOffsetX + col * squareSize + squareSize / 2;
+			piece.y = boardOffsetY + row * squareSize + squareSize / 2;
+			game.addChild(piece);
+			pieces.push(piece);
+			gameBoard[row][col] = piece;
+			if (piece.pieceType === 'King') {
+				blackKing = piece;
+			}
+		}
+	}
+	// White pieces
+	for (var row = 6; row < 8; row++) {
+		for (var col = 0; col < 8; col++) {
+			var pieceIndex = row === 6 ? 1 : 0;
+			var piece = new ChessPiece(initialSetup[pieceIndex][col], 'white', row, col);
+			piece.x = boardOffsetX + col * squareSize + squareSize / 2;
+			piece.y = boardOffsetY + row * squareSize + squareSize / 2;
+			game.addChild(piece);
+			pieces.push(piece);
+			gameBoard[row][col] = piece;
+			if (piece.pieceType === 'King') {
+				whiteKing = piece;
+			}
+		}
+	}
+}
+function isValidPosition(row, col) {
+	return row >= 0 && row < 8 && col >= 0 && col < 8;
+}
+function getPawnMoves(piece) {
+	var moves = [];
+	var direction = piece.color === 'white' ? -1 : 1;
+	var startRow = piece.color === 'white' ? 6 : 1;
+	// Move forward one square
+	var newRow = piece.row + direction;
+	if (isValidPosition(newRow, piece.col) && !gameBoard[newRow][piece.col]) {
+		moves.push({
+			row: newRow,
+			col: piece.col
+		});
+		// Move forward two squares from starting position
+		if (piece.row === startRow) {
+			newRow = piece.row + direction * 2;
+			if (isValidPosition(newRow, piece.col) && !gameBoard[newRow][piece.col]) {
+				moves.push({
+					row: newRow,
+					col: piece.col
+				});
+			}
+		}
+	}
+	// Capture diagonally
+	for (var colOffset = -1; colOffset <= 1; colOffset += 2) {
+		newRow = piece.row + direction;
+		var newCol = piece.col + colOffset;
+		if (isValidPosition(newRow, newCol)) {
+			var targetPiece = gameBoard[newRow][newCol];
+			if (targetPiece && targetPiece.color !== piece.color) {
+				moves.push({
+					row: newRow,
+					col: newCol
+				});
+			}
+		}
+	}
+	return moves;
+}
+function getRookMoves(piece) {
+	var moves = [];
+	var directions = [[-1, 0], [1, 0], [0, -1], [0, 1]];
+	for (var d = 0; d < directions.length; d++) {
+		var dir = directions[d];
+		for (var i = 1; i < 8; i++) {
+			var newRow = piece.row + dir[0] * i;
+			var newCol = piece.col + dir[1] * i;
+			if (!isValidPosition(newRow, newCol)) break;
+			var targetPiece = gameBoard[newRow][newCol];
+			if (targetPiece) {
+				if (targetPiece.color !== piece.color) {
+					moves.push({
+						row: newRow,
+						col: newCol
+					});
+				}
+				break;
+			} else {
+				moves.push({
+					row: newRow,
+					col: newCol
+				});
+			}
+		}
+	}
+	return moves;
+}
+function getKnightMoves(piece) {
+	var moves = [];
+	var knightMoves = [[-2, -1], [-2, 1], [-1, -2], [-1, 2], [1, -2], [1, 2], [2, -1], [2, 1]];
+	for (var i = 0; i < knightMoves.length; i++) {
+		var move = knightMoves[i];
+		var newRow = piece.row + move[0];
+		var newCol = piece.col + move[1];
+		if (isValidPosition(newRow, newCol)) {
+			var targetPiece = gameBoard[newRow][newCol];
+			if (!targetPiece || targetPiece.color !== piece.color) {
+				moves.push({
+					row: newRow,
+					col: newCol
+				});
+			}
+		}
+	}
+	return moves;
+}
+function getBishopMoves(piece) {
+	var moves = [];
+	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 = piece.row + dir[0] * i;
+			var newCol = piece.col + dir[1] * i;
+			if (!isValidPosition(newRow, newCol)) break;
+			var targetPiece = gameBoard[newRow][newCol];
+			if (targetPiece) {
+				if (targetPiece.color !== piece.color) {
+					moves.push({
+						row: newRow,
+						col: newCol
+					});
+				}
+				break;
+			} else {
+				moves.push({
+					row: newRow,
+					col: newCol
+				});
+			}
+		}
+	}
+	return moves;
+}
+function getQueenMoves(piece) {
+	var moves = getRookMoves(piece);
+	return moves.concat(getBishopMoves(piece));
+}
+function getKingMoves(piece) {
+	var moves = [];
+	var directions = [[-1, -1], [-1, 0], [-1, 1], [0, -1], [0, 1], [1, -1], [1, 0], [1, 1]];
+	for (var i = 0; i < directions.length; i++) {
+		var dir = directions[i];
+		var newRow = piece.row + dir[0];
+		var newCol = piece.col + dir[1];
+		if (isValidPosition(newRow, newCol)) {
+			var targetPiece = gameBoard[newRow][newCol];
+			if (!targetPiece || targetPiece.color !== piece.color) {
+				moves.push({
+					row: newRow,
+					col: newCol
+				});
+			}
+		}
+	}
+	return moves;
+}
+function isInCheck(color) {
+	var king = color === 'white' ? whiteKing : blackKing;
+	if (!king) return false;
+	for (var i = 0; i < pieces.length; i++) {
+		var piece = pieces[i];
+		if (piece.color !== color && piece.parent) {
+			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 isCheckmate(color) {
+	if (!isInCheck(color)) return false;
+	for (var i = 0; i < pieces.length; i++) {
+		var piece = pieces[i];
+		if (piece.color === color && piece.parent) {
+			var moves = piece.getValidMoves();
+			for (var j = 0; j < moves.length; j++) {
+				if (isValidMove(piece, moves[j].row, moves[j].col)) {
+					return false;
+				}
+			}
+		}
+	}
+	return true;
+}
+function isValidMove(piece, targetRow, targetCol) {
+	if (!isValidPosition(targetRow, targetCol)) return false;
+	var targetPiece = gameBoard[targetRow][targetCol];
+	if (targetPiece && targetPiece.color === piece.color) return false;
+	// Test if move would put own king in check
+	var originalRow = piece.row;
+	var originalCol = piece.col;
+	var capturedPiece = gameBoard[targetRow][targetCol];
+	// Simulate move
+	gameBoard[originalRow][originalCol] = null;
+	gameBoard[targetRow][targetCol] = piece;
+	piece.row = targetRow;
+	piece.col = targetCol;
+	var inCheck = isInCheck(piece.color);
+	// Restore position
+	gameBoard[originalRow][originalCol] = piece;
+	gameBoard[targetRow][targetCol] = capturedPiece;
+	piece.row = originalRow;
+	piece.col = originalCol;
+	return !inCheck;
+}
+function makeMove(piece, targetRow, targetCol) {
+	var capturedPiece = gameBoard[targetRow][targetCol];
+	// Remove 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('captureSound').play();
+	} else {
+		LK.getSound('moveSound').play();
+	}
+	// Update board
+	gameBoard[piece.row][piece.col] = null;
+	gameBoard[targetRow][targetCol] = piece;
+	// Move piece
+	piece.moveTo(targetRow, targetCol);
+	// Switch turns
+	currentTurn = currentTurn === 'white' ? 'black' : 'white';
+	turnText.setText(currentTurn === 'white' ? 'White\'s Turn' : 'Black\'s Turn');
+	// Check for checkmate
+	if (isCheckmate(currentTurn)) {
+		var winner = currentTurn === 'white' ? 'Black' : 'White';
+		turnText.setText(winner + ' Wins!');
+		gameOver = true;
+		LK.setTimeout(function () {
+			LK.showYouWin();
+		}, 2000);
+	} else if (isInCheck(currentTurn)) {
+		board.highlightSquare(currentTurn === 'white' ? whiteKing.row : blackKing.row, currentTurn === 'white' ? whiteKing.col : blackKing.col, 'checkSquare');
+	}
+}
+function getPieceAt(x, y) {
+	var boardX = x - boardOffsetX;
+	var boardY = y - boardOffsetY;
+	if (boardX < 0 || boardX >= boardSize || boardY < 0 || boardY >= boardSize) {
+		return null;
+	}
+	var col = Math.floor(boardX / squareSize);
+	var row = Math.floor(boardY / squareSize);
+	return gameBoard[row][col];
+}
+function getBoardPosition(x, y) {
+	var boardX = x - boardOffsetX;
+	var boardY = y - boardOffsetY;
+	if (boardX < 0 || boardX >= boardSize || boardY < 0 || boardY >= boardSize) {
+		return null;
+	}
+	var col = Math.floor(boardX / squareSize);
+	var row = Math.floor(boardY / squareSize);
+	return {
+		row: row,
+		col: col
+	};
+}
+game.down = function (x, y, obj) {
+	if (gameOver) return;
+	var clickedPiece = getPieceAt(x, y);
+	var boardPos = getBoardPosition(x, y);
+	if (!boardPos) return;
+	if (selectedPiece) {
+		// Try to move selected piece
+		if (clickedPiece === selectedPiece) {
+			// Deselect piece
+			selectedPiece = null;
+			board.clearHighlights();
+		} else {
+			// Check if this is a valid move
+			var validMoves = selectedPiece.getValidMoves();
+			var isValid = false;
+			for (var i = 0; i < validMoves.length; i++) {
+				if (validMoves[i].row === boardPos.row && validMoves[i].col === boardPos.col) {
+					if (isValidMove(selectedPiece, boardPos.row, boardPos.col)) {
+						isValid = true;
+						break;
+					}
+				}
+			}
+			if (isValid) {
+				makeMove(selectedPiece, boardPos.row, boardPos.col);
+				selectedPiece = null;
+				board.clearHighlights();
+			} else if (clickedPiece && clickedPiece.color === currentTurn) {
+				// Select new piece
+				selectedPiece = clickedPiece;
+				board.clearHighlights();
+				board.highlightSquare(selectedPiece.row, selectedPiece.col);
+				var moves = selectedPiece.getValidMoves();
+				for (var j = 0; j < moves.length; j++) {
+					if (isValidMove(selectedPiece, moves[j].row, moves[j].col)) {
+						board.highlightSquare(moves[j].row, moves[j].col, 'validMoveSquare');
+					}
+				}
+			} else {
+				selectedPiece = null;
+				board.clearHighlights();
+			}
+		}
+	} else if (clickedPiece && clickedPiece.color === currentTurn) {
+		// Select piece
+		selectedPiece = clickedPiece;
+		board.highlightSquare(selectedPiece.row, selectedPiece.col);
+		var moves = selectedPiece.getValidMoves();
+		for (var k = 0; k < moves.length; k++) {
+			if (isValidMove(selectedPiece, moves[k].row, moves[k].col)) {
+				board.highlightSquare(moves[k].row, moves[k].col, 'validMoveSquare');
+			}
+		}
+	}
+};
+// Setup the game
+setupPieces();
\ No newline at end of file