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

/**** 
* Classes
****/ 
var GameTile = Container.expand(function (leftType, rightType, leftCrowns, rightCrowns, number) {
	var self = Container.call(this);
	self.leftType = leftType;
	self.rightType = rightType;
	self.leftCrowns = leftCrowns;
	self.rightCrowns = rightCrowns;
	self.number = number;
	self.selected = false;
	self.rotation = 0; // 0, 90, 180, 270 degrees
	self.isDragging = false;
	self.ownerPlayer = null; // Track which player owns this tile
	// Create tile background
	var bg = self.addChild(LK.getAsset('tileSlot', {
		anchorX: 0.5,
		anchorY: 0.5
	}));
	// Create terrain sections
	var leftTerrain = self.addChild(LK.getAsset(leftType, {
		x: -60,
		y: 0,
		anchorX: 0.5,
		anchorY: 0.5
	}));
	var rightTerrain = self.addChild(LK.getAsset(rightType, {
		x: 60,
		y: 0,
		anchorX: 0.5,
		anchorY: 0.5
	}));
	// Add crowns
	for (var i = 0; i < leftCrowns; i++) {
		self.addChild(LK.getAsset('crown', {
			x: -60 + i * 15 - 7.5,
			y: -35,
			anchorX: 0.5,
			anchorY: 0.5
		}));
	}
	for (var i = 0; i < rightCrowns; i++) {
		self.addChild(LK.getAsset('crown', {
			x: 60 + i * 15 - 7.5,
			y: -35,
			anchorX: 0.5,
			anchorY: 0.5
		}));
	}
	// Add number
	var numberText = self.addChild(new Text2(number.toString(), {
		size: 30,
		fill: 0xFFFFFF
	}));
	numberText.anchor.set(0.5, 0.5);
	numberText.x = 0;
	numberText.y = 70;
	// Add rotation button (only visible when selected)
	var rotateBtn = self.addChild(new Text2('↻', {
		size: 30,
		fill: 0x00FF00
	}));
	rotateBtn.anchor.set(0.5, 0.5);
	rotateBtn.x = 100;
	rotateBtn.y = -50;
	rotateBtn.alpha = 0;
	self.rotateBtn = rotateBtn;
	// Store original terrain references for rotation
	self.leftTerrain = leftTerrain;
	self.rightTerrain = rightTerrain;
	self.rotateTile = function () {
		self.rotation = (self.rotation + 90) % 360;
		self.updateTileVisuals();
	};
	self.updateTileVisuals = function () {
		// Normalize rotation to 0, 90, 180, or 270 degrees
		self.rotation = (self.rotation % 360 + 360) % 360;
		if (self.rotation % 90 !== 0) {
			self.rotation = Math.round(self.rotation / 90) * 90;
		}
		// Update terrain positions based on rotation
		var leftX, leftY, rightX, rightY;
		if (self.rotation === 0) {
			leftX = -60;
			leftY = 0;
			rightX = 60;
			rightY = 0;
		} else if (self.rotation === 90) {
			leftX = 0;
			leftY = -60;
			rightX = 0;
			rightY = 60;
		} else if (self.rotation === 180) {
			leftX = 60;
			leftY = 0;
			rightX = -60;
			rightY = 0;
		} else {
			// 270
			leftX = 0;
			leftY = 60;
			rightX = 0;
			rightY = -60;
		}
		self.leftTerrain.x = leftX;
		self.leftTerrain.y = leftY;
		self.rightTerrain.x = rightX;
		self.rightTerrain.y = rightY;
		// Update crowns positions
		var leftCrownStartX = leftX;
		var leftCrownStartY = leftY - 35;
		var rightCrownStartX = rightX;
		var rightCrownStartY = rightY - 35;
		// Remove existing crowns and recreate them
		for (var i = self.children.length - 1; i >= 0; i--) {
			if (self.children[i].isCrown) {
				self.removeChild(self.children[i]);
			}
		}
		// Add left crowns
		for (var i = 0; i < self.leftCrowns; i++) {
			var crown = self.addChild(LK.getAsset('crown', {
				x: leftCrownStartX + i * 15 - 7.5,
				y: leftCrownStartY,
				anchorX: 0.5,
				anchorY: 0.5
			}));
			crown.isCrown = true;
		}
		// Add right crowns
		for (var i = 0; i < self.rightCrowns; i++) {
			var crown = self.addChild(LK.getAsset('crown', {
				x: rightCrownStartX + i * 15 - 7.5,
				y: rightCrownStartY,
				anchorX: 0.5,
				anchorY: 0.5
			}));
			crown.isCrown = true;
		}
	};
	self.setSelected = function (selected) {
		self.selected = selected;
		if (selected) {
			if (!self.selectedBg) {
				self.selectedBg = self.addChildAt(LK.getAsset('selectedTile', {
					anchorX: 0.5,
					anchorY: 0.5
				}), 0);
			}
			self.rotateBtn.alpha = 1;
		} else {
			if (self.selectedBg) {
				self.removeChild(self.selectedBg);
				self.selectedBg = null;
			}
			self.rotateBtn.alpha = 0;
		}
	};
	self.down = function (x, y, obj) {
		// Prevent interaction if tile is owned by AI player or during AI turn
		if (self.ownerPlayer && self.ownerPlayer !== 0) return;
		if (gameState === 'aiTurn') return;
		if (gameState === 'selectTile' && currentPlayer === 0) {
			selectTile(self);
		} else if (gameState === 'placeTile' && currentPlayer === 0 && self.selected) {
			// Check if clicked on rotation button using local coordinates directly
			if (x > 85 && x < 115 && y > -65 && y < -35) {
				self.rotateTile();
				LK.getSound('selectSound').play();
			} else {
				// Start dragging
				self.isDragging = true;
				draggedTile = self;
			}
		}
	};
	return self;
});
var Kingdom = Container.expand(function (playerIndex) {
	var self = Container.call(this);
	self.playerIndex = playerIndex;
	self.grid = [];
	self.score = 0;
	// Initialize 5x5 grid
	for (var i = 0; i < 5; i++) {
		self.grid[i] = [];
		for (var j = 0; j < 5; j++) {
			self.grid[i][j] = null;
		}
	}
	// Place castle at center
	self.grid[2][2] = {
		type: 'castle',
		crowns: 0
	};
	// Draw kingdom grid
	self.drawKingdom = function () {
		// Clear existing visuals
		for (var i = self.children.length - 1; i >= 0; i--) {
			self.removeChild(self.children[i]);
		}
		for (var i = 0; i < 5; i++) {
			for (var j = 0; j < 5; j++) {
				var cell = self.addChild(LK.getAsset('kingdomCell', {
					x: j * 125,
					y: i * 125,
					anchorX: 0,
					anchorY: 0
				}));
				if (self.grid[i][j]) {
					var terrain = self.addChild(LK.getAsset(self.grid[i][j].type, {
						x: j * 125 + 62.5,
						y: i * 125 + 62.5,
						anchorX: 0.5,
						anchorY: 0.5
					}));
					// Add crowns if present
					for (var c = 0; c < self.grid[i][j].crowns; c++) {
						var crown = self.addChild(LK.getAsset('crown', {
							x: j * 125 + 62.5 + c * 15 - 7.5,
							y: i * 125 + 35,
							anchorX: 0.5,
							anchorY: 0.5
						}));
					}
				}
			}
		}
	};
	self.canPlaceTile = function (tile, row, col) {
		// Check if positions are valid and empty based on rotation
		var positions = self.getTilePositions(tile, row, col);
		if (!positions) return false;
		if (self.grid[positions[0][0]][positions[0][1]] !== null || self.grid[positions[1][0]][positions[1][1]] !== null) return false;
		// Check if adjacent to existing kingdom
		var adjacent = false;
		var positions = [[row, col], [row, col + 1]];
		for (var p = 0; p < positions.length; p++) {
			var r = positions[p][0];
			var c = positions[p][1];
			// Check all 4 directions
			var directions = [[-1, 0], [1, 0], [0, -1], [0, 1]];
			for (var d = 0; d < directions.length; d++) {
				var nr = r + directions[d][0];
				var nc = c + directions[d][1];
				if (nr >= 0 && nr < 5 && nc >= 0 && nc < 5 && self.grid[nr][nc] !== null) {
					adjacent = true;
					break;
				}
			}
			if (adjacent) break;
		}
		if (!adjacent) return false;
		// Check terrain matching (except for first tile after castle)
		var hasNonCastleNeighbor = false;
		for (var p = 0; p < positions.length; p++) {
			var r = positions[p][0];
			var c = positions[p][1];
			var directions = [[-1, 0], [1, 0], [0, -1], [0, 1]];
			for (var d = 0; d < directions.length; d++) {
				var nr = r + directions[d][0];
				var nc = c + directions[d][1];
				if (nr >= 0 && nr < 5 && nc >= 0 && nc < 5 && self.grid[nr][nc] !== null) {
					if (self.grid[nr][nc].type !== 'castle') {
						hasNonCastleNeighbor = true;
						var terrainIndex = p;
						var tileType = terrainIndex === 0 ? tile.leftType : tile.rightType;
						if (self.grid[nr][nc].type !== tileType) {
							return false;
						}
					}
				}
			}
		}
		return true;
	};
	self.getTilePositions = function (tile, row, col) {
		var positions;
		if (tile.rotation === 0) {
			// Horizontal: left-right
			if (col >= 4) return null;
			positions = [[row, col], [row, col + 1]];
		} else if (tile.rotation === 90) {
			// Vertical: top-bottom  
			if (row >= 4) return null;
			positions = [[row, col], [row + 1, col]];
		} else if (tile.rotation === 180) {
			// Horizontal: right-left
			if (col >= 4) return null;
			positions = [[row, col + 1], [row, col]];
		} else {
			// 270
			// Vertical: bottom-top
			if (row >= 4) return null;
			positions = [[row + 1, col], [row, col]];
		}
		// Check bounds
		for (var i = 0; i < positions.length; i++) {
			if (positions[i][0] < 0 || positions[i][0] >= 5 || positions[i][1] < 0 || positions[i][1] >= 5) {
				return null;
			}
		}
		return positions;
	};
	self.placeTile = function (tile, row, col) {
		var positions = self.getTilePositions(tile, row, col);
		if (!positions) return false;
		// Place based on rotation
		if (tile.rotation === 0 || tile.rotation === 180) {
			// Horizontal placement
			self.grid[positions[0][0]][positions[0][1]] = {
				type: tile.leftType,
				crowns: tile.leftCrowns
			};
			self.grid[positions[1][0]][positions[1][1]] = {
				type: tile.rightType,
				crowns: tile.rightCrowns
			};
		} else {
			// Vertical placement
			self.grid[positions[0][0]][positions[0][1]] = {
				type: tile.leftType,
				crowns: tile.leftCrowns
			};
			self.grid[positions[1][0]][positions[1][1]] = {
				type: tile.rightType,
				crowns: tile.rightCrowns
			};
		}
		self.drawKingdom();
		return true;
	};
	self.calculateScore = function () {
		var visited = [];
		var totalScore = 0;
		for (var i = 0; i < 5; i++) {
			visited[i] = [];
			for (var j = 0; j < 5; j++) {
				visited[i][j] = false;
			}
		}
		for (var i = 0; i < 5; i++) {
			for (var j = 0; j < 5; j++) {
				if (!visited[i][j] && self.grid[i][j] && self.grid[i][j].type !== 'castle') {
					var result = self.floodFill(i, j, self.grid[i][j].type, visited);
					totalScore += result.size * result.crowns;
				}
			}
		}
		self.score = totalScore;
		return totalScore;
	};
	self.floodFill = function (row, col, terrainType, visited) {
		if (row < 0 || row >= 5 || col < 0 || col >= 5) return {
			size: 0,
			crowns: 0
		};
		if (visited[row][col]) return {
			size: 0,
			crowns: 0
		};
		if (!self.grid[row][col] || self.grid[row][col].type !== terrainType) return {
			size: 0,
			crowns: 0
		};
		visited[row][col] = true;
		var size = 1;
		var crowns = self.grid[row][col].crowns;
		var directions = [[-1, 0], [1, 0], [0, -1], [0, 1]];
		for (var d = 0; d < directions.length; d++) {
			var result = self.floodFill(row + directions[d][0], col + directions[d][1], terrainType, visited);
			size += result.size;
			crowns += result.crowns;
		}
		return {
			size: size,
			crowns: crowns
		};
	};
	self.drawKingdom();
	return self;
});

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

/**** 
* Game Code
****/ 
// Initialize basic game assets
// Game state variables
var gameState = 'selectTile'; // 'selectTile', 'placeTile', 'gameOver'
var currentPlayer = 0;
var round = 1;
var maxRounds = 12;
var selectedTile = null;
var draggedTile = null;
var placementRow = -1;
var placementCol = -1;
// Player kingdoms
var kingdoms = [];
var players = ['Human', 'AI1', 'AI2', 'AI3'];
var turnOrder = [0, 1, 2, 3];
// Tile deck
var tileDeck = [];
var currentTiles = [];
var selectedTiles = [];
// UI elements
var scoreTxt = new Text2('Round: 1', {
	size: 60,
	fill: 0xFFFFFF
});
scoreTxt.anchor.set(0.5, 0);
LK.gui.top.addChild(scoreTxt);
var playerScoreTxt = new Text2('Your Score: 0', {
	size: 45,
	fill: 0xFFFFFF
});
playerScoreTxt.anchor.set(0, 0);
playerScoreTxt.x = 50;
playerScoreTxt.y = 150;
LK.gui.topLeft.addChild(playerScoreTxt);
var instructionTxt = new Text2('Select a tile', {
	size: 40,
	fill: 0xFFFFFF
});
instructionTxt.anchor.set(0.5, 1);
LK.gui.bottom.addChild(instructionTxt);
// Turn order display
var turnOrderContainer = new Container();
turnOrderContainer.x = -200;
turnOrderContainer.y = 50;
LK.gui.topRight.addChild(turnOrderContainer);
var turnOrderTexts = [];
for (var i = 0; i < 4; i++) {
	var turnText = new Text2('', {
		size: 35,
		fill: 0xFFFFFF
	});
	turnText.anchor.set(1, 0);
	turnText.y = i * 45;
	turnOrderContainer.addChild(turnText);
	turnOrderTexts.push(turnText);
}
// Update turn order display
function updateTurnOrderDisplay() {
	var playerNames = ['YOU', 'AI 1', 'AI 2', 'AI 3'];
	for (var i = 0; i < 4; i++) {
		if (turnOrderTexts[i]) {
			var playerIndex = turnOrder[i];
			var isCurrentPlayer = i === turnOrder.indexOf(currentPlayer);
			turnOrderTexts[i].setText(i + 1 + '. ' + playerNames[playerIndex]);
			turnOrderTexts[i].tint = isCurrentPlayer ? 0x00FF00 : 0xFFFFFF;
		}
	}
}
// Initialize tile deck
function initializeTileDeck() {
	// Complete set of 48 Kingdomino tiles with exact terrain and crown combinations
	var tileData = [
	// Tiles 1-8: Wheat fields
	{
		leftType: 'wheat',
		rightType: 'wheat',
		leftCrowns: 0,
		rightCrowns: 0
	}, {
		leftType: 'wheat',
		rightType: 'wheat',
		leftCrowns: 0,
		rightCrowns: 0
	}, {
		leftType: 'wheat',
		rightType: 'wheat',
		leftCrowns: 0,
		rightCrowns: 0
	}, {
		leftType: 'wheat',
		rightType: 'wheat',
		leftCrowns: 0,
		rightCrowns: 0
	}, {
		leftType: 'wheat',
		rightType: 'wheat',
		leftCrowns: 0,
		rightCrowns: 0
	}, {
		leftType: 'wheat',
		rightType: 'grassland',
		leftCrowns: 0,
		rightCrowns: 0
	}, {
		leftType: 'wheat',
		rightType: 'lake',
		leftCrowns: 0,
		rightCrowns: 0
	}, {
		leftType: 'wheat',
		rightType: 'grassland',
		leftCrowns: 0,
		rightCrowns: 0
	},
	// Tiles 9-16: Grassland
	{
		leftType: 'grassland',
		rightType: 'grassland',
		leftCrowns: 0,
		rightCrowns: 0
	}, {
		leftType: 'grassland',
		rightType: 'grassland',
		leftCrowns: 0,
		rightCrowns: 0
	}, {
		leftType: 'grassland',
		rightType: 'grassland',
		leftCrowns: 0,
		rightCrowns: 0
	}, {
		leftType: 'grassland',
		rightType: 'grassland',
		leftCrowns: 0,
		rightCrowns: 0
	}, {
		leftType: 'grassland',
		rightType: 'lake',
		leftCrowns: 0,
		rightCrowns: 0
	}, {
		leftType: 'grassland',
		rightType: 'lake',
		leftCrowns: 0,
		rightCrowns: 0
	}, {
		leftType: 'grassland',
		rightType: 'forest',
		leftCrowns: 0,
		rightCrowns: 0
	}, {
		leftType: 'grassland',
		rightType: 'forest',
		leftCrowns: 0,
		rightCrowns: 0
	},
	// Tiles 17-24: Forest
	{
		leftType: 'forest',
		rightType: 'forest',
		leftCrowns: 0,
		rightCrowns: 0
	}, {
		leftType: 'forest',
		rightType: 'forest',
		leftCrowns: 0,
		rightCrowns: 0
	}, {
		leftType: 'forest',
		rightType: 'forest',
		leftCrowns: 0,
		rightCrowns: 0
	}, {
		leftType: 'forest',
		rightType: 'forest',
		leftCrowns: 0,
		rightCrowns: 0
	}, {
		leftType: 'forest',
		rightType: 'lake',
		leftCrowns: 0,
		rightCrowns: 0
	}, {
		leftType: 'forest',
		rightType: 'lake',
		leftCrowns: 0,
		rightCrowns: 0
	}, {
		leftType: 'forest',
		rightType: 'grassland',
		leftCrowns: 0,
		rightCrowns: 0
	}, {
		leftType: 'forest',
		rightType: 'grassland',
		leftCrowns: 0,
		rightCrowns: 0
	},
	// Tiles 25-32: Lake
	{
		leftType: 'lake',
		rightType: 'lake',
		leftCrowns: 0,
		rightCrowns: 0
	}, {
		leftType: 'lake',
		rightType: 'lake',
		leftCrowns: 0,
		rightCrowns: 0
	}, {
		leftType: 'lake',
		rightType: 'lake',
		leftCrowns: 0,
		rightCrowns: 0
	}, {
		leftType: 'lake',
		rightType: 'lake',
		leftCrowns: 0,
		rightCrowns: 0
	}, {
		leftType: 'lake',
		rightType: 'forest',
		leftCrowns: 0,
		rightCrowns: 0
	}, {
		leftType: 'lake',
		rightType: 'forest',
		leftCrowns: 0,
		rightCrowns: 0
	}, {
		leftType: 'wheat',
		rightType: 'lake',
		leftCrowns: 1,
		rightCrowns: 0
	}, {
		leftType: 'wheat',
		rightType: 'grassland',
		leftCrowns: 1,
		rightCrowns: 0
	},
	// Tiles 33-40: Swamp and Mine
	{
		leftType: 'swamp',
		rightType: 'swamp',
		leftCrowns: 0,
		rightCrowns: 0
	}, {
		leftType: 'swamp',
		rightType: 'grassland',
		leftCrowns: 0,
		rightCrowns: 0
	}, {
		leftType: 'mine',
		rightType: 'mine',
		leftCrowns: 0,
		rightCrowns: 0
	}, {
		leftType: 'mine',
		rightType: 'grassland',
		leftCrowns: 0,
		rightCrowns: 0
	}, {
		leftType: 'grassland',
		rightType: 'mine',
		leftCrowns: 0,
		rightCrowns: 1
	}, {
		leftType: 'grassland',
		rightType: 'swamp',
		leftCrowns: 0,
		rightCrowns: 1
	}, {
		leftType: 'forest',
		rightType: 'grassland',
		leftCrowns: 0,
		rightCrowns: 1
	}, {
		leftType: 'forest',
		rightType: 'wheat',
		leftCrowns: 0,
		rightCrowns: 1
	},
	// Tiles 41-48: Crown tiles
	{
		leftType: 'wheat',
		rightType: 'forest',
		leftCrowns: 1,
		rightCrowns: 0
	}, {
		leftType: 'wheat',
		rightType: 'lake',
		leftCrowns: 1,
		rightCrowns: 0
	}, {
		leftType: 'grassland',
		rightType: 'lake',
		leftCrowns: 1,
		rightCrowns: 0
	}, {
		leftType: 'forest',
		rightType: 'lake',
		leftCrowns: 1,
		rightCrowns: 0
	}, {
		leftType: 'swamp',
		rightType: 'forest',
		leftCrowns: 1,
		rightCrowns: 1
	}, {
		leftType: 'mine',
		rightType: 'wheat',
		leftCrowns: 2,
		rightCrowns: 0
	}, {
		leftType: 'swamp',
		rightType: 'mine',
		leftCrowns: 2,
		rightCrowns: 1
	}, {
		leftType: 'mine',
		rightType: 'mine',
		leftCrowns: 3,
		rightCrowns: 0
	}];
	// Create shuffled deck
	var shuffledIndices = [];
	for (var i = 0; i < 48; i++) {
		shuffledIndices.push(i);
	}
	// Shuffle the indices
	for (var i = shuffledIndices.length - 1; i > 0; i--) {
		var j = Math.floor(Math.random() * (i + 1));
		var temp = shuffledIndices[i];
		shuffledIndices[i] = shuffledIndices[j];
		shuffledIndices[j] = temp;
	}
	// Create tileDeck with shuffled order but maintain original numbering
	for (var i = 0; i < 48; i++) {
		var data = tileData[shuffledIndices[i]];
		tileDeck.push({
			leftType: data.leftType,
			rightType: data.rightType,
			leftCrowns: data.leftCrowns,
			rightCrowns: data.rightCrowns,
			number: i + 1
		});
	}
}
// Initialize kingdoms
function initializeKingdoms() {
	for (var i = 0; i < 4; i++) {
		var kingdom = new Kingdom(i);
		kingdoms.push(kingdom);
		// Position kingdoms around the screen
		if (i === 0) {
			// Human player - bottom center, moved left more
			kingdom.x = 1024 - 312 - 100; // Center horizontally (625 width / 2) moved left by 100 more
			kingdom.y = 2050; // Move up slightly
			kingdom.scaleX = 1.0;
			kingdom.scaleY = 1.0;
			game.addChild(kingdom);
			// Add player label above kingdom
			var playerLabel = new Text2('YOUR KINGDOM', {
				size: 40,
				fill: 0xFFFFFF
			});
			playerLabel.anchor.set(0.5, 1);
			playerLabel.x = kingdom.x + 312;
			playerLabel.y = kingdom.y - 20; // Above kingdom
			game.addChild(playerLabel);
		} else if (i === 1) {
			// AI 1 - top center, moved left more
			kingdom.x = 1024 - 312 - 100; // Center horizontally moved left by 100 more
			kingdom.y = 100;
			kingdom.scaleX = 1.0;
			kingdom.scaleY = 1.0;
			game.addChild(kingdom);
			// Add player label
			var playerLabel = new Text2('AI PLAYER 1', {
				size: 40,
				fill: 0xFFFFFF
			});
			playerLabel.anchor.set(0.5, 0);
			playerLabel.x = kingdom.x + 312;
			playerLabel.y = kingdom.y + 625 + 20; // Below kingdom
			game.addChild(playerLabel);
		} else if (i === 2) {
			// AI 2 - right center, moved left slightly
			kingdom.x = 1400 + 50;
			kingdom.y = 1366 - 312; // Center vertically
			kingdom.scaleX = 1.0;
			kingdom.scaleY = 1.0;
			game.addChild(kingdom);
			// Add player label
			var playerLabel = new Text2('AI PLAYER 2', {
				size: 40,
				fill: 0xFFFFFF
			});
			playerLabel.anchor.set(0.5, 0);
			playerLabel.x = kingdom.x + 312;
			playerLabel.y = kingdom.y + 625 + 20; // Below kingdom
			game.addChild(playerLabel);
		} else if (i === 3) {
			// AI 3 - left center, moved left slightly
			kingdom.x = 20 + 50;
			kingdom.y = 1366 - 312; // Center vertically
			kingdom.scaleX = 1.0;
			kingdom.scaleY = 1.0;
			game.addChild(kingdom);
			// Add player label
			var playerLabel = new Text2('AI PLAYER 3', {
				size: 40,
				fill: 0xFFFFFF
			});
			playerLabel.anchor.set(0.5, 0);
			playerLabel.x = kingdom.x + 312;
			playerLabel.y = kingdom.y + 625 + 20; // Below kingdom
			game.addChild(playerLabel);
		}
	}
}
// Draw current tiles
function drawCurrentTiles() {
	// Clear existing tiles
	for (var i = 0; i < currentTiles.length; i++) {
		if (currentTiles[i].parent) {
			currentTiles[i].parent.removeChild(currentTiles[i]);
		}
	}
	currentTiles = [];
	// Get 4 tiles and sort them by number
	var tilesToShow = [];
	for (var i = 0; i < 4; i++) {
		if (tileDeck.length > 0) {
			tilesToShow.push(tileDeck.shift());
		}
	}
	// Sort tiles by number (lowest to highest)
	tilesToShow.sort(function (a, b) {
		return a.number - b.number;
	});
	// Draw sorted tiles in a column centered on screen, moved down
	for (var i = 0; i < tilesToShow.length; i++) {
		var tileData = tilesToShow[i];
		var tile = new GameTile(tileData.leftType, tileData.rightType, tileData.leftCrowns, tileData.rightCrowns, tileData.number);
		tile.x = 1024; // Center horizontally (screen width / 2)
		tile.y = 1366 - 200 + i * 250; // Move down more (changed from -500 to -200)
		currentTiles.push(tile);
		game.addChild(tile);
	}
}
// Select tile
function selectTile(tile) {
	if (gameState !== 'selectTile' || currentPlayer !== 0) return;
	if (selectedTile) {
		selectedTile.setSelected(false);
	}
	selectedTile = tile;
	tile.setSelected(true);
	gameState = 'placeTile';
	updateTurnOrderDisplay();
	instructionTxt.setText('Click to place tile on your kingdom');
	LK.getSound('selectSound').play();
}
// AI turn
function aiTurn() {
	if (currentPlayer === 0) return;
	// Prevent user interaction during AI turn
	gameState = 'aiTurn';
	updateTurnOrderDisplay();
	// AI selects random available tile
	var availableTiles = [];
	for (var i = 0; i < currentTiles.length; i++) {
		if (!currentTiles[i].selected) {
			availableTiles.push(currentTiles[i]);
		}
	}
	if (availableTiles.length > 0) {
		var randomTile = availableTiles[Math.floor(Math.random() * availableTiles.length)];
		selectedTile = randomTile;
		randomTile.setSelected(true);
		// Mark tile as owned by current AI player to prevent user interaction
		randomTile.ownerPlayer = currentPlayer;
		instructionTxt.setText('AI Player ' + currentPlayer + ' selecting tile...');
		LK.getSound('selectSound').play();
		// Delay before placing tile
		LK.setTimeout(function () {
			// AI places tile randomly with rotation attempts
			var kingdom = kingdoms[currentPlayer];
			var placed = false;
			for (var attempts = 0; attempts < 200 && !placed; attempts++) {
				var row = Math.floor(Math.random() * 5);
				var col = Math.floor(Math.random() * 4);
				// Try different rotations
				for (var rot = 0; rot < 4 && !placed; rot++) {
					// Set rotation internally without visual update
					var originalRotation = selectedTile.rotation;
					selectedTile.rotation = rot * 90;
					if (kingdom.canPlaceTile(selectedTile, row, col)) {
						// Update visuals only when placing
						selectedTile.updateTileVisuals();
						kingdom.placeTile(selectedTile, row, col);
						placed = true;
					} else {
						// Restore original rotation if placement failed
						selectedTile.rotation = originalRotation;
					}
				}
			}
			if (placed) {
				selectedTiles.push({
					tile: selectedTile,
					player: currentPlayer
				});
				// Remove tile from display
				selectedTile.parent.removeChild(selectedTile);
				selectedTile = null;
				LK.getSound('placeSound').play();
			}
			instructionTxt.setText('AI Player ' + currentPlayer + ' placed tile');
			LK.setTimeout(function () {
				nextPlayer();
			}, 1000);
		}, 1000);
	}
}
// Next player
function nextPlayer() {
	// Check if all 4 players have selected tiles in this round
	if (selectedTiles.length === 4) {
		// All players finished, start new round
		round++;
		if (round > maxRounds) {
			endGame();
			return;
		}
		// Update turn order based on selected tiles
		selectedTiles.sort(function (a, b) {
			return a.tile.number - b.tile.number;
		});
		turnOrder = [];
		for (var i = 0; i < selectedTiles.length; i++) {
			turnOrder.push(selectedTiles[i].player);
		}
		selectedTiles = [];
		currentPlayer = turnOrder[0];
		drawCurrentTiles();
		scoreTxt.setText('Round: ' + round);
		updateTurnOrderDisplay();
		if (currentPlayer === 0) {
			gameState = 'selectTile';
			instructionTxt.setText('Select a tile');
		} else {
			LK.setTimeout(aiTurn, 500);
		}
	} else {
		// Move to next player in current round
		var currentTurnIndex = turnOrder.indexOf(currentPlayer);
		var nextTurnIndex = (currentTurnIndex + 1) % 4;
		currentPlayer = turnOrder[nextTurnIndex];
		updateTurnOrderDisplay();
		if (currentPlayer !== 0) {
			LK.setTimeout(aiTurn, 500);
		} else {
			gameState = 'selectTile';
			instructionTxt.setText('Select a tile');
		}
	}
}
// End game
function endGame() {
	gameState = 'gameOver';
	// Calculate final scores
	var finalScores = [];
	for (var i = 0; i < kingdoms.length; i++) {
		finalScores.push({
			player: i,
			score: kingdoms[i].calculateScore()
		});
	}
	finalScores.sort(function (a, b) {
		return b.score - a.score;
	});
	var playerRank = 1;
	for (var i = 0; i < finalScores.length; i++) {
		if (finalScores[i].player === 0) {
			playerRank = i + 1;
			break;
		}
	}
	if (playerRank === 1) {
		LK.showYouWin();
	} else {
		LK.showGameOver();
	}
}
// Kingdom click handler
function handleKingdomClick(x, y) {
	if (gameState !== 'placeTile' || currentPlayer !== 0 || !selectedTile) return;
	var kingdom = kingdoms[0];
	// Convert click coordinates to kingdom local coordinates
	// Account for kingdom position offset
	var relativeX = x - kingdom.x;
	var relativeY = y - kingdom.y;
	// Calculate grid position based on cell size (125px)
	var row = Math.floor(relativeY / 125);
	var col = Math.floor(relativeX / 125);
	// Ensure coordinates are within valid bounds
	if (row < 0 || row >= 5 || col < 0 || col >= 5) return;
	// For horizontal tiles, ensure there's space for both cells
	if ((selectedTile.rotation === 0 || selectedTile.rotation === 180) && col >= 4) {
		col = 3; // Ensure tile fits horizontally
	}
	// For vertical tiles, ensure there's space for both cells
	if ((selectedTile.rotation === 90 || selectedTile.rotation === 270) && row >= 4) {
		row = 3; // Ensure tile fits vertically
	}
	if (kingdom.canPlaceTile(selectedTile, row, col)) {
		kingdom.placeTile(selectedTile, row, col);
		selectedTiles.push({
			tile: selectedTile,
			player: currentPlayer
		});
		// Remove tile from game
		selectedTile.parent.removeChild(selectedTile);
		selectedTile = null;
		LK.getSound('placeSound').play();
		gameState = 'waitingForOthers';
		instructionTxt.setText('Wait for other players...');
		// Update score
		playerScoreTxt.setText('Your Score: ' + kingdom.calculateScore());
		nextPlayer();
	}
}
// Game move handler for dragging
game.move = function (x, y, obj) {
	if (draggedTile && draggedTile.isDragging) {
		draggedTile.x = x;
		draggedTile.y = y;
	}
};
// Game up handler for dropping tiles
game.up = function (x, y, obj) {
	if (draggedTile && draggedTile.isDragging) {
		draggedTile.isDragging = false;
		// Try to place tile on kingdom
		handleKingdomClick(x, y);
		draggedTile = null;
	}
};
// Game event handlers
game.down = function (x, y, obj) {
	if (gameState === 'placeTile' && currentPlayer === 0 && !draggedTile) {
		handleKingdomClick(x, y);
	}
};
game.update = function () {
	// Game update logic handled by event system and timeouts
};
// Initialize game
initializeTileDeck();
initializeKingdoms();
drawCurrentTiles();
// Start with human player
gameState = 'selectTile';
updateTurnOrderDisplay();
instructionTxt.setText('Select a tile');

===================================================================
--- original.js
+++ change.js
@@ -749,10 +749,10 @@
 		var kingdom = new Kingdom(i);
 		kingdoms.push(kingdom);
 		// Position kingdoms around the screen
 		if (i === 0) {
-			// Human player - bottom center, moved left slightly
-			kingdom.x = 1024 - 312 + 50; // Center horizontally (625 width / 2) + 50 right (moved left by 50 more)
+			// Human player - bottom center, moved left more
+			kingdom.x = 1024 - 312 - 100; // Center horizontally (625 width / 2) moved left by 100 more
 			kingdom.y = 2050; // Move up slightly
 			kingdom.scaleX = 1.0;
 			kingdom.scaleY = 1.0;
 			game.addChild(kingdom);
@@ -765,10 +765,10 @@
 			playerLabel.x = kingdom.x + 312;
 			playerLabel.y = kingdom.y - 20; // Above kingdom
 			game.addChild(playerLabel);
 		} else if (i === 1) {
-			// AI 1 - top center, moved left slightly
-			kingdom.x = 1024 - 312 + 50; // Center horizontally + 50 right (moved left by 50 more)
+			// AI 1 - top center, moved left more
+			kingdom.x = 1024 - 312 - 100; // Center horizontally moved left by 100 more
 			kingdom.y = 100;
 			kingdom.scaleX = 1.0;
 			kingdom.scaleY = 1.0;
 			game.addChild(kingdom);
@@ -835,14 +835,14 @@
 	// Sort tiles by number (lowest to highest)
 	tilesToShow.sort(function (a, b) {
 		return a.number - b.number;
 	});
-	// Draw sorted tiles in a column centered on screen
+	// Draw sorted tiles in a column centered on screen, moved down
 	for (var i = 0; i < tilesToShow.length; i++) {
 		var tileData = tilesToShow[i];
 		var tile = new GameTile(tileData.leftType, tileData.rightType, tileData.leftCrowns, tileData.rightCrowns, tileData.number);
 		tile.x = 1024; // Center horizontally (screen width / 2)
-		tile.y = 1366 - 500 + i * 250; // Move down and reduce spacing
+		tile.y = 1366 - 200 + i * 250; // Move down more (changed from -500 to -200)
 		currentTiles.push(tile);
 		game.addChild(tile);
 	}
 }