/**** 
* 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 pieceTypeMap = {
		'pawn': color === 'white' ? 'beyazPiyon' : 'siyahPiyon',
		'rook': color === 'white' ? 'beyazKale' : 'siyahKale',
		'knight': color === 'white' ? 'beyazAt' : 'siyahAt',
		'bishop': color === 'white' ? 'beyazFil' : 'siyahFil',
		'queen': color === 'white' ? 'beyazVezir' : 'siyahVezir',
		'king': color === 'white' ? 'beyazSah' : 'siyahSah'
	};
	var assetId = pieceTypeMap[type];
	var pieceGraphics = self.attachAsset(assetId, {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.down = function (x, y, obj) {
		if (gameState !== 'playing') return;
		if (currentPlayer === self.color) {
			// Select this piece if it belongs to current player
			selectedPiece = self;
			selectedSquare = {
				row: self.row,
				col: self.col
			};
			validMoves = getValidMoves(self);
			updateBoardDisplay();
		} else if (selectedPiece && isValidMove(selectedPiece.row, selectedPiece.col, self.row, self.col)) {
			// If clicking on opponent piece and it's a valid capture move
			movePiece(selectedPiece, self.row, self.col);
		}
	};
	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
					});
				}
			}
		}
		// Castling moves
		if (!piece.hasMoved) {
			var kingRow = piece.row;
			// Kingside castling (short castling)
			var kingsideRook = board[kingRow][7];
			if (kingsideRook && kingsideRook.pieceType === 'rook' && kingsideRook.color === piece.color && !kingsideRook.hasMoved) {
				// Check if squares between king and rook are empty
				if (!board[kingRow][5] && !board[kingRow][6]) {
					// For now, add the move (should also check if king passes through check)
					moves.push({
						row: kingRow,
						col: 6,
						isCastling: true,
						castlingType: 'kingside'
					});
				}
			}
			// Queenside castling (long castling)
			var queensideRook = board[kingRow][0];
			if (queensideRook && queensideRook.pieceType === 'rook' && queensideRook.color === piece.color && !queensideRook.hasMoved) {
				// Check if squares between king and rook are empty
				if (!board[kingRow][1] && !board[kingRow][2] && !board[kingRow][3]) {
					// For now, add the move (should also check if king passes through check)
					moves.push({
						row: kingRow,
						col: 2,
						isCastling: true,
						castlingType: 'queenside'
					});
				}
			}
		}
	} 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 isInCheck(playerColor) {
	// Find the king of the specified color
	var king = null;
	for (var i = 0; i < pieces.length; i++) {
		if (pieces[i].pieceType === 'king' && pieces[i].color === playerColor) {
			king = pieces[i];
			break;
		}
	}
	if (!king) return false;
	// Check if any opponent piece can attack the king
	for (var i = 0; i < pieces.length; i++) {
		var piece = pieces[i];
		if (piece.color !== playerColor) {
			var moves = getValidMoves(piece);
			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(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) {
	// Check if this is a castling move
	var isCastlingMove = false;
	var castlingType = '';
	if (piece.pieceType === 'king' && !piece.hasMoved && Math.abs(newCol - piece.col) === 2) {
		isCastlingMove = true;
		castlingType = newCol > piece.col ? 'kingside' : 'queenside';
	}
	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('yeme').play();
	} else {
		LK.getSound('hareket').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;
	// Handle castling - move the rook
	if (isCastlingMove) {
		LK.getSound('rok').play();
		var rookOldCol, rookNewCol;
		if (castlingType === 'kingside') {
			rookOldCol = 7;
			rookNewCol = 5;
		} else {
			// queenside
			rookOldCol = 0;
			rookNewCol = 3;
		}
		var rook = board[newRow][rookOldCol];
		if (rook) {
			// Remove rook from old position
			board[newRow][rookOldCol] = null;
			// Update rook position
			rook.row = newRow;
			rook.col = rookNewCol;
			rook.hasMoved = true;
			// Place rook in new position
			board[newRow][rookNewCol] = rook;
			// Animate rook movement
			tween(rook, {
				x: rookNewCol * 225 + 112.5,
				y: newRow * 225 + 112.5
			}, {
				duration: 300,
				easing: tween.easeOut
			});
		}
	}
	// 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';
	// Check if the current player is in check
	if (isInCheck(currentPlayer)) {
		LK.getSound('sah').play();
	}
	updateGameStatus();
	// Check for pawn promotion
	if (piece.pieceType === 'pawn' && (piece.row === 0 || piece.row === 7)) {
		LK.getSound('terfi').play();
		showPromotionDialog(piece);
	}
	// 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';
	LK.getSound('bitis').play();
	// 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;
}
function showPromotionDialog(piece) {
	// Create dialog background
	var dialogBg = LK.getAsset('chessBoard', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	dialogBg.x = 1024;
	dialogBg.y = 1366;
	dialogBg.width = 800;
	dialogBg.height = 600;
	dialogBg.tint = 0x444444;
	game.addChild(dialogBg);
	// Dialog title
	var titleText = new Text2('Taş Seçin', {
		size: 60,
		fill: 0xFFFFFF
	});
	titleText.anchor.set(0.5, 0.5);
	titleText.x = 1024;
	titleText.y = 1200;
	game.addChild(titleText);
	// Promotion options
	var promotionOptions = ['queen', 'rook', 'bishop', 'knight'];
	var optionNames = ['Vezir', 'Kale', 'Fil', 'At'];
	var buttons = [];
	for (var i = 0; i < promotionOptions.length; i++) {
		var button = LK.getAsset('betButton', {
			anchorX: 0.5,
			anchorY: 0.5
		});
		button.x = 1024;
		button.y = 1300 + i * 100;
		button.width = 300;
		button.height = 80;
		game.addChild(button);
		var buttonText = new Text2(optionNames[i], {
			size: 40,
			fill: 0xFFFFFF
		});
		buttonText.anchor.set(0.5, 0.5);
		buttonText.x = 1024;
		buttonText.y = 1300 + i * 100;
		game.addChild(buttonText);
		// Store piece type for this button
		button.pieceType = promotionOptions[i];
		button.dialogElements = [dialogBg, titleText, buttonText];
		// Add all buttons to cleanup list
		for (var j = 0; j < buttons.length; j++) {
			button.dialogElements.push(buttons[j]);
			button.dialogElements.push(buttons[j].textElement);
		}
		button.down = function () {
			// Promote the piece
			promotePiece(piece, this.pieceType);
			// Clean up dialog
			for (var k = 0; k < this.dialogElements.length; k++) {
				if (this.dialogElements[k].parent) {
					this.dialogElements[k].parent.removeChild(this.dialogElements[k]);
				}
				this.dialogElements[k].destroy();
			}
			// Clean up remaining buttons
			for (var l = 0; l < buttons.length; l++) {
				if (buttons[l].parent) {
					buttons[l].parent.removeChild(buttons[l]);
				}
				if (buttons[l].textElement && buttons[l].textElement.parent) {
					buttons[l].textElement.parent.removeChild(buttons[l].textElement);
				}
				buttons[l].destroy();
				if (buttons[l].textElement) {
					buttons[l].textElement.destroy();
				}
			}
		};
		button.textElement = buttonText;
		buttons.push(button);
	}
}
function promotePiece(piece, newType) {
	// Update piece type
	piece.pieceType = newType;
	// Update the visual representation
	piece.removeChildren();
	var pieceTypeMap = {
		'pawn': piece.color === 'white' ? 'beyazPiyon' : 'siyahPiyon',
		'rook': piece.color === 'white' ? 'beyazKale' : 'siyahKale',
		'knight': piece.color === 'white' ? 'beyazAt' : 'siyahAt',
		'bishop': piece.color === 'white' ? 'beyazFil' : 'siyahFil',
		'queen': piece.color === 'white' ? 'beyazVezir' : 'siyahVezir',
		'king': piece.color === 'white' ? 'beyazSah' : 'siyahSah'
	};
	var assetId = pieceTypeMap[newType];
	var pieceGraphics = piece.attachAsset(assetId, {
		anchorX: 0.5,
		anchorY: 0.5
	});
}
// Initialize everything
createBoardDisplay();
initializeBoard();
createUI();
updateBoardDisplay();
game.update = function () {
	// Game loop - handle any continuous updates if needed
};

===================================================================
--- original.js
+++ change.js
@@ -13,9 +13,17 @@
 	self.color = color;
 	self.row = row;
 	self.col = col;
 	self.hasMoved = false;
-	var assetId = color + type.charAt(0).toUpperCase() + type.slice(1);
+	var pieceTypeMap = {
+		'pawn': color === 'white' ? 'beyazPiyon' : 'siyahPiyon',
+		'rook': color === 'white' ? 'beyazKale' : 'siyahKale',
+		'knight': color === 'white' ? 'beyazAt' : 'siyahAt',
+		'bishop': color === 'white' ? 'beyazFil' : 'siyahFil',
+		'queen': color === 'white' ? 'beyazVezir' : 'siyahVezir',
+		'king': color === 'white' ? 'beyazSah' : 'siyahSah'
+	};
+	var assetId = pieceTypeMap[type];
 	var pieceGraphics = self.attachAsset(assetId, {
 		anchorX: 0.5,
 		anchorY: 0.5
 	});
@@ -758,9 +766,17 @@
 	// Update piece type
 	piece.pieceType = newType;
 	// Update the visual representation
 	piece.removeChildren();
-	var assetId = piece.color + newType.charAt(0).toUpperCase() + newType.slice(1);
+	var pieceTypeMap = {
+		'pawn': piece.color === 'white' ? 'beyazPiyon' : 'siyahPiyon',
+		'rook': piece.color === 'white' ? 'beyazKale' : 'siyahKale',
+		'knight': piece.color === 'white' ? 'beyazAt' : 'siyahAt',
+		'bishop': piece.color === 'white' ? 'beyazFil' : 'siyahFil',
+		'queen': piece.color === 'white' ? 'beyazVezir' : 'siyahVezir',
+		'king': piece.color === 'white' ? 'beyazSah' : 'siyahSah'
+	};
+	var assetId = pieceTypeMap[newType];
 	var pieceGraphics = piece.attachAsset(assetId, {
 		anchorX: 0.5,
 		anchorY: 0.5
 	});