/**** 
* Plugins
****/ 
var tween = LK.import("@upit/tween.v1");
var storage = LK.import("@upit/storage.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 assetId = color + type.charAt(0).toUpperCase() + type.slice(1);
	var pieceGraphics = self.attachAsset(assetId, {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.down = function (x, y, obj) {
		if (currentPlayer !== self.color) return;
		if (gameState !== 'playing') return;
		selectedPiece = self;
		selectedSquare = {
			row: self.row,
			col: self.col
		};
		validMoves = getValidMoves(self);
		updateBoardDisplay();
	};
	return self;
});
var Square = Container.expand(function (row, col, isLight) {
	var self = Container.call(this);
	self.row = row;
	self.col = col;
	self.isLight = isLight;
	self.piece = null;
	var squareGraphics = self.attachAsset(isLight ? 'lightSquare' : 'darkSquare', {
		anchorX: 0,
		anchorY: 0
	});
	self.down = function (x, y, obj) {
		if (gameState !== 'playing') return;
		if (selectedPiece && isValidMove(selectedPiece.row, selectedPiece.col, self.row, self.col)) {
			movePiece(selectedPiece, self.row, self.col);
		} else {
			// Check if there's a piece on this square that belongs to current player
			var pieceOnSquare = board[self.row][self.col];
			if (pieceOnSquare && pieceOnSquare.color === currentPlayer) {
				// Select this piece if it belongs to current player
				selectedPiece = pieceOnSquare;
				selectedSquare = {
					row: self.row,
					col: self.col
				};
				validMoves = getValidMoves(pieceOnSquare);
				updateBoardDisplay();
			} else {
				clearSelection();
			}
		}
	};
	return self;
});

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

/**** 
* Game Code
****/ 
// Game state variables
var gameState = 'betting'; // 'betting', 'playing', 'gameOver'
var currentPlayer = 'white';
var selectedPiece = null;
var selectedSquare = null;
var validMoves = [];
var board = [];
var pieces = [];
// Player data
var playerStars = storage.playerStars || 10;
var opponentStars = storage.opponentStars || 10;
var playerBet = 0;
var opponentBet = 0;
var betPhase = 'playerBetting'; // 'playerBetting', 'opponentBetting', 'waitingForOpponent'
// UI elements
var boardContainer = new Container();
var squareOverlays = [];
var starDisplay, betDisplay, gameStatusDisplay;
// Initialize chess board
function initializeBoard() {
	board = [];
	pieces = [];
	// Create 8x8 board
	for (var row = 0; row < 8; row++) {
		board[row] = [];
		for (var col = 0; col < 8; col++) {
			board[row][col] = null;
		}
	}
	// Setup initial piece positions - standard chess layout
	var backRankSetup = ['rook', 'knight', 'bishop', 'queen', 'king', 'bishop', 'knight', 'rook'];
	// Place black pieces (rows 0-1, top of board)
	// Row 0: Black back rank
	for (var col = 0; col < 8; col++) {
		var piece = new ChessPiece(backRankSetup[col], 'black', 0, col);
		pieces.push(piece);
		board[0][col] = piece;
		boardContainer.addChild(piece);
		piece.x = col * 225 + 112.5;
		piece.y = 0 * 225 + 112.5;
	}
	// Row 1: Black pawns
	for (var col = 0; col < 8; col++) {
		var piece = new ChessPiece('pawn', 'black', 1, col);
		pieces.push(piece);
		board[1][col] = piece;
		boardContainer.addChild(piece);
		piece.x = col * 225 + 112.5;
		piece.y = 1 * 225 + 112.5;
	}
	// Place white pieces (rows 6-7, bottom of board)
	// Row 6: White pawns
	for (var col = 0; col < 8; col++) {
		var piece = new ChessPiece('pawn', 'white', 6, col);
		pieces.push(piece);
		board[6][col] = piece;
		boardContainer.addChild(piece);
		piece.x = col * 225 + 112.5;
		piece.y = 6 * 225 + 112.5;
	}
	// Row 7: White back rank
	for (var col = 0; col < 8; col++) {
		var piece = new ChessPiece(backRankSetup[col], 'white', 7, col);
		pieces.push(piece);
		board[7][col] = piece;
		boardContainer.addChild(piece);
		piece.x = col * 225 + 112.5;
		piece.y = 7 * 225 + 112.5;
	}
}
// Create visual board squares
function createBoardDisplay() {
	boardContainer.x = 124;
	boardContainer.y = 466;
	game.addChild(boardContainer);
	// Create board background
	var boardBg = boardContainer.attachAsset('chessBoard', {
		anchorX: 0,
		anchorY: 0
	});
	// Create squares
	for (var row = 0; row < 8; row++) {
		squareOverlays[row] = [];
		for (var col = 0; col < 8; col++) {
			var isLight = (row + col) % 2 === 0;
			var square = new Square(row, col, isLight);
			square.x = col * 225;
			square.y = row * 225;
			boardContainer.addChild(square);
			squareOverlays[row][col] = square;
		}
	}
}
// Get valid moves for a piece
function getValidMoves(piece) {
	var moves = [];
	if (piece.pieceType === 'pawn') {
		var direction = piece.color === 'white' ? -1 : 1;
		var startRow = piece.color === 'white' ? 6 : 1;
		// Forward move
		if (isValidSquare(piece.row + direction, piece.col) && !board[piece.row + direction][piece.col]) {
			moves.push({
				row: piece.row + direction,
				col: piece.col
			});
			// Double move from start
			if (piece.row === startRow && !board[piece.row + 2 * direction][piece.col]) {
				moves.push({
					row: piece.row + 2 * direction,
					col: piece.col
				});
			}
		}
		// Captures
		for (var dc = -1; dc <= 1; dc += 2) {
			var newRow = piece.row + direction;
			var newCol = piece.col + dc;
			if (isValidSquare(newRow, newCol) && board[newRow][newCol] && board[newRow][newCol].color !== piece.color) {
				moves.push({
					row: newRow,
					col: newCol
				});
			}
		}
	} else if (piece.pieceType === 'rook') {
		// Horizontal and vertical moves
		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 = piece.row + dir[0] * i;
				var newCol = piece.col + dir[1] * i;
				if (!isValidSquare(newRow, newCol)) break;
				var targetPiece = board[newRow][newCol];
				if (!targetPiece) {
					moves.push({
						row: newRow,
						col: newCol
					});
				} else {
					if (targetPiece.color !== piece.color) {
						moves.push({
							row: newRow,
							col: newCol
						});
					}
					break;
				}
			}
		}
	} else if (piece.pieceType === 'bishop') {
		// Diagonal 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 (!isValidSquare(newRow, newCol)) break;
				var targetPiece = board[newRow][newCol];
				if (!targetPiece) {
					moves.push({
						row: newRow,
						col: newCol
					});
				} else {
					if (targetPiece.color !== piece.color) {
						moves.push({
							row: newRow,
							col: newCol
						});
					}
					break;
				}
			}
		}
	} else if (piece.pieceType === 'queen') {
		// Combination of rook and bishop moves
		var directions = [[0, 1], [0, -1], [1, 0], [-1, 0], [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 (!isValidSquare(newRow, newCol)) break;
				var targetPiece = board[newRow][newCol];
				if (!targetPiece) {
					moves.push({
						row: newRow,
						col: newCol
					});
				} else {
					if (targetPiece.color !== piece.color) {
						moves.push({
							row: newRow,
							col: newCol
						});
					}
					break;
				}
			}
		}
	} else if (piece.pieceType === 'king') {
		// One square in any direction
		var directions = [[0, 1], [0, -1], [1, 0], [-1, 0], [1, 1], [1, -1], [-1, 1], [-1, -1]];
		for (var d = 0; d < directions.length; d++) {
			var dir = directions[d];
			var newRow = piece.row + dir[0];
			var newCol = piece.col + dir[1];
			if (isValidSquare(newRow, newCol)) {
				var targetPiece = board[newRow][newCol];
				if (!targetPiece || targetPiece.color !== piece.color) {
					moves.push({
						row: newRow,
						col: newCol
					});
				}
			}
		}
	} else if (piece.pieceType === 'knight') {
		// L-shaped moves
		var knightMoves = [[2, 1], [2, -1], [-2, 1], [-2, -1], [1, 2], [1, -2], [-1, 2], [-1, -2]];
		for (var m = 0; m < knightMoves.length; m++) {
			var move = knightMoves[m];
			var newRow = piece.row + move[0];
			var newCol = piece.col + move[1];
			if (isValidSquare(newRow, newCol)) {
				var targetPiece = board[newRow][newCol];
				if (!targetPiece || targetPiece.color !== piece.color) {
					moves.push({
						row: newRow,
						col: newCol
					});
				}
			}
		}
	}
	return moves;
}
function isValidSquare(row, col) {
	return row >= 0 && row < 8 && col >= 0 && col < 8;
}
function isValidMove(fromRow, fromCol, toRow, toCol) {
	for (var i = 0; i < validMoves.length; i++) {
		if (validMoves[i].row === toRow && validMoves[i].col === toCol) {
			return true;
		}
	}
	return false;
}
function movePiece(piece, newRow, newCol) {
	var capturedPiece = board[newRow][newCol];
	// Handle capture first (before moving the piece)
	if (capturedPiece && capturedPiece.color !== piece.color) {
		// Remove captured piece from pieces array
		for (var i = pieces.length - 1; i >= 0; i--) {
			if (pieces[i] === capturedPiece) {
				pieces.splice(i, 1);
				break;
			}
		}
		// Remove captured piece from board container
		if (capturedPiece.parent) {
			capturedPiece.parent.removeChild(capturedPiece);
		}
		// Destroy the visual representation
		capturedPiece.destroy();
		LK.getSound('capture').play();
	} else {
		LK.getSound('pieceMove').play();
	}
	// Remove piece from old position on board
	board[piece.row][piece.col] = null;
	// Update piece position data
	piece.row = newRow;
	piece.col = newCol;
	piece.hasMoved = true;
	// Place piece in new position on board
	board[newRow][newCol] = piece;
	// Animate piece movement
	tween(piece, {
		x: newCol * 225 + 112.5,
		y: newRow * 225 + 112.5
	}, {
		duration: 300,
		easing: tween.easeOut
	});
	// Clear selection
	clearSelection();
	// Switch turns
	currentPlayer = currentPlayer === 'white' ? 'black' : 'white';
	updateGameStatus();
	// Check for game over conditions
	checkGameOver();
}
function clearSelection() {
	selectedPiece = null;
	selectedSquare = null;
	validMoves = [];
	updateBoardDisplay();
}
function updateBoardDisplay() {
	// Clear all overlays
	for (var row = 0; row < 8; row++) {
		for (var col = 0; col < 8; col++) {
			var square = squareOverlays[row][col];
			square.removeChildren();
			var isLight = (row + col) % 2 === 0;
			var squareGraphics = square.attachAsset(isLight ? 'lightSquare' : 'darkSquare', {
				anchorX: 0,
				anchorY: 0
			});
		}
	}
	// Show selected square
	if (selectedSquare) {
		var selectedSquareOverlay = squareOverlays[selectedSquare.row][selectedSquare.col];
		selectedSquareOverlay.removeChildren();
		var selectedGraphics = selectedSquareOverlay.attachAsset('selectedSquare', {
			anchorX: 0,
			anchorY: 0
		});
	}
	// Show valid moves
	for (var i = 0; i < validMoves.length; i++) {
		var move = validMoves[i];
		var moveSquare = squareOverlays[move.row][move.col];
		moveSquare.removeChildren();
		var moveGraphics = moveSquare.attachAsset('validMoveSquare', {
			anchorX: 0,
			anchorY: 0
		});
	}
}
function checkGameOver() {
	// Simple game over check - if king is captured
	var whiteKingExists = false;
	var blackKingExists = false;
	for (var i = 0; i < pieces.length; i++) {
		var piece = pieces[i];
		if (piece.pieceType === 'king') {
			if (piece.color === 'white') whiteKingExists = true;
			if (piece.color === 'black') blackKingExists = true;
		}
	}
	if (!whiteKingExists) {
		endGame('black');
	} else if (!blackKingExists) {
		endGame('white');
	}
}
function endGame(winner) {
	gameState = 'gameOver';
	// Award stars
	if (winner === 'white') {
		playerStars += opponentBet;
		opponentStars -= opponentBet;
	} else {
		playerStars -= playerBet;
		opponentStars += playerBet;
	}
	// Save to storage
	storage.playerStars = playerStars;
	storage.opponentStars = opponentStars;
	updateStarDisplay();
	if (winner === 'white') {
		LK.showYouWin();
	} else {
		LK.showGameOver();
	}
}
function createUI() {
	// Star display
	starDisplay = new Text2('Yıldızlar: ' + playerStars, {
		size: 60,
		fill: 0xFFFFFF
	});
	starDisplay.anchor.set(0.5, 0);
	LK.gui.top.addChild(starDisplay);
	starDisplay.y = 100;
	// Game status display
	gameStatusDisplay = new Text2('Bahis yapın!', {
		size: 50,
		fill: 0xFFFFFF
	});
	gameStatusDisplay.anchor.set(0.5, 0);
	LK.gui.top.addChild(gameStatusDisplay);
	gameStatusDisplay.y = 180;
	// Betting interface
	createBettingUI();
}
function createBettingUI() {
	// Bet amount display
	betDisplay = new Text2('Bahis: ' + playerBet + ' yıldız', {
		size: 50,
		fill: 0xFFFFFF
	});
	betDisplay.anchor.set(0.5, 1);
	LK.gui.bottom.addChild(betDisplay);
	betDisplay.y = -200;
	// Bet buttons
	var decreaseBetBtn = LK.getAsset('betButton', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	var increaseBetBtn = LK.getAsset('betButton', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	var confirmBetBtn = LK.getAsset('betButton', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	LK.gui.bottom.addChild(decreaseBetBtn);
	LK.gui.bottom.addChild(increaseBetBtn);
	LK.gui.bottom.addChild(confirmBetBtn);
	decreaseBetBtn.x = -200;
	decreaseBetBtn.y = -100;
	increaseBetBtn.x = 0;
	increaseBetBtn.y = -100;
	confirmBetBtn.x = 200;
	confirmBetBtn.y = -100;
	var decreaseText = new Text2('-', {
		size: 40,
		fill: 0xFFFFFF
	});
	decreaseText.anchor.set(0.5, 0.5);
	decreaseBetBtn.addChild(decreaseText);
	var increaseText = new Text2('+', {
		size: 40,
		fill: 0xFFFFFF
	});
	increaseText.anchor.set(0.5, 0.5);
	increaseBetBtn.addChild(increaseText);
	var confirmText = new Text2('Onayla', {
		size: 30,
		fill: 0xFFFFFF
	});
	confirmText.anchor.set(0.5, 0.5);
	confirmBetBtn.addChild(confirmText);
	// Button interactions
	decreaseBetBtn.down = function () {
		if (playerBet > 0) {
			playerBet--;
			updateBetDisplay();
		}
	};
	increaseBetBtn.down = function () {
		if (playerBet < playerStars) {
			playerBet++;
			updateBetDisplay();
		}
	};
	confirmBetBtn.down = function () {
		if (gameState === 'betting') {
			confirmBet();
		}
	};
}
function updateBetDisplay() {
	betDisplay.setText('Bahis: ' + playerBet + ' yıldız');
}
function updateStarDisplay() {
	starDisplay.setText('Yıldızlar: ' + playerStars);
}
function updateGameStatus() {
	if (gameState === 'betting') {
		gameStatusDisplay.setText('Bahis yapın!');
	} else if (gameState === 'playing') {
		var playerName = currentPlayer === 'white' ? 'Beyaz' : 'Siyah';
		gameStatusDisplay.setText(playerName + ' sırası');
	}
}
function confirmBet() {
	// For now, simulate opponent bet (random between 0 and their stars)
	opponentBet = Math.floor(Math.random() * (Math.min(opponentStars, 10) + 1));
	gameState = 'playing';
	updateGameStatus();
	// Hide betting UI
	LK.gui.bottom.removeChildren();
	// Show bet results
	var betResultText = new Text2('Sizin bahis: ' + playerBet + ' | Rakip bahis: ' + opponentBet, {
		size: 40,
		fill: 0xFFFFFF
	});
	betResultText.anchor.set(0.5, 1);
	LK.gui.bottom.addChild(betResultText);
	betResultText.y = -50;
}
// Initialize everything
createBoardDisplay();
initializeBoard();
createUI();
updateBoardDisplay();
game.update = function () {
	// Game loop - handle any continuous updates if needed
};

===================================================================
--- original.js
+++ change.js
@@ -21,10 +21,8 @@
 	});
 	self.down = function (x, y, obj) {
 		if (currentPlayer !== self.color) return;
 		if (gameState !== 'playing') return;
-		// Stop event propagation to prevent square handler from also triggering
-		obj.stopPropagation = true;
 		selectedPiece = self;
 		selectedSquare = {
 			row: self.row,
 			col: self.col