/**** 
* Classes
****/ 
var ActionButton = Container.expand(function () {
	var self = Container.call(this);
	self.init = function (text, action, x, y) {
		self.action = action;
		// Button graphics
		self.buttonGraphics = self.attachAsset('actionButton', {
			anchorX: 0.5,
			anchorY: 0.5
		});
		// Button text
		self.buttonText = new Text2(text, {
			size: 28,
			fill: 0xFFFFFF
		});
		self.buttonText.anchor.set(0.5, 0.5);
		self.addChild(self.buttonText);
		self.x = x;
		self.y = y;
		return self;
	};
	self.down = function (x, y, obj) {
		if (self.action) {
			self.action();
		}
	};
	return self;
});
var DiplomacyPanel = Container.expand(function () {
	var self = Container.call(this);
	self.init = function (targetCountry) {
		self.targetCountry = targetCountry;
		self.visible = false;
		// Panel background
		self.panelBg = LK.getAsset('actionButton', {
			anchorX: 0.5,
			anchorY: 0.5,
			scaleX: 3,
			scaleY: 4
		});
		self.panelBg.tint = 0x2c3e50;
		self.addChild(self.panelBg);
		// Panel title
		self.titleText = new Text2("Diplomacy with Country " + targetCountry, {
			size: 32,
			fill: 0xFFFFFF
		});
		self.titleText.anchor.set(0.5, 0.5);
		self.titleText.y = -80;
		self.addChild(self.titleText);
		// Declare war button
		self.warButton = new ActionButton();
		self.warButton.init("Declare War", function () {
			declareWar(targetCountry);
			self.hide();
		}, 0, 0);
		// Hide declare war button in easy mode
		if (selectedDifficulty === "easy") {
			self.warButton.visible = false;
		}
		self.addChild(self.warButton);
		// Close button
		self.closeButton = new ActionButton();
		self.closeButton.init("Close", function () {
			self.hide();
		}, 0, 60);
		self.addChild(self.closeButton);
		// Position panel in center of screen
		self.x = 2048 / 2;
		self.y = 2732 / 2;
		return self;
	};
	self.show = function () {
		self.visible = true;
		game.addChild(self);
	};
	self.hide = function () {
		self.visible = false;
		if (self.parent) {
			self.parent.removeChild(self);
		}
	};
	return self;
});
var Ship = Container.expand(function () {
	var self = Container.call(this);
	self.init = function (owner, x, y) {
		self.owner = owner;
		self.hp = 3; // Ships have more health than armies
		self.selected = false;
		// Ship graphics
		self.shipGraphics = self.attachAsset('ship', {
			anchorX: 0.5,
			anchorY: 0.5
		});
		// Color based on owner
		if (owner === 1) {
			self.shipGraphics.tint = 0x27ae60; // Green for player
		} else if (owner === 2) {
			self.shipGraphics.tint = 0xe74c3c; // Red for enemy
		}
		// HP display
		self.hpText = new Text2(self.hp.toString(), {
			size: 20,
			fill: 0xFFFFFF
		});
		self.hpText.anchor.set(0.5, 0.5);
		self.hpText.x = 0;
		self.hpText.y = -35;
		self.addChild(self.hpText);
		self.x = x;
		self.y = y;
		return self;
	};
	self.takeDamage = function (damage) {
		self.hp -= damage;
		self.hpText.setText(self.hp.toString());
		return self.hp <= 0;
	};
	self.down = function (x, y, obj) {
		if (gameState === 'playing' && self.owner === 1) {
			selectShip(self);
			// Show possible moves for this ship (all sea territories) when clicked
			// Remove all previous highlights first
			for (var i = 0; i < territories.length; i++) {
				if (territories[i].isSea) {
					territories[i].showAsTarget = true;
					territories[i].updateGraphics();
				}
			}
		} else if (gameState === 'playing' && selectedShip && selectedShip.owner === 1 && self.owner === 2) {
			// Check if ships are close enough for naval combat
			var distance = Math.abs(selectedShip.x - self.x) + Math.abs(selectedShip.y - self.y);
			if (distance < 200) {
				// Initiate naval combat
				navalCombat(selectedShip, self);
				selectedShip.selected = false;
				selectedShip.shipGraphics.tint = 0x27ae60; // Reset color
				selectedShip = null;
				endPlayerTurn();
			}
		}
	};
	return self;
});
// Game state variables
var Territory = Container.expand(function () {
	var self = Container.call(this);
	self.init = function (id, x, y, owner, isSea) {
		self.id = id;
		self.owner = owner; // 0 = neutral, 1 = player, 2 = enemy
		self.isSea = isSea || false;
		self.armies = owner === 0 || self.isSea ? 0 : Math.floor(Math.random() * 3) + 1;
		self.selected = false;
		self.lastSelected = false;
		// Create territory graphics
		self.updateGraphics();
		// Position
		self.x = x;
		self.y = y;
		// Army display (only for land territories)
		if (!self.isSea) {
			self.armyText = new Text2(self.armies.toString(), {
				size: 24,
				fill: 0x000000
			});
			self.armyText.anchor.set(0.5, 0.5);
			self.armyText.x = 0;
			self.armyText.y = 0;
			self.addChild(self.armyText);
		}
		return self;
	};
	self.updateGraphics = function () {
		// Remove existing graphics
		if (self.graphics) {
			self.removeChild(self.graphics);
		}
		var assetName = 'seaTerritory'; // Default to sea
		if (self.isSea) {
			assetName = 'seaTerritory';
		} else if (self.selected) {
			assetName = 'selectedTerritory';
		} else if (self.showAsTarget) {
			assetName = 'targetTerritory';
		} else {
			// Assign different country colors based on owner
			if (self.owner === 1) {
				assetName = 'country1Territory'; // Green for player
			} else if (self.owner === 2) {
				assetName = 'country2Territory'; // Red for enemy
			} else if (self.owner === 3) {
				assetName = 'country3Territory'; // Blue
			} else if (self.owner === 4) {
				assetName = 'country4Territory'; // Purple
			} else if (self.owner === 5) {
				assetName = 'country5Territory'; // Orange
			} else if (self.owner === 6) {
				assetName = 'country6Territory'; // Cyan
			} else if (self.isColonizable) {
				assetName = 'colonizableTerritory'; // Use dedicated gray asset for colonizable territories
			} else {
				assetName = 'seaTerritory'; // Unassigned territories become sea
			}
		}
		self.graphics = self.attachAsset(assetName, {
			anchorX: 0.5,
			anchorY: 0.5
		});
	};
	self.setOwner = function (newOwner, armies) {
		self.owner = newOwner;
		if (!self.isSea) {
			self.armies = armies || 1;
			self.armyText.setText(self.armies.toString());
		}
		self.updateGraphics();
	};
	self.addArmies = function (count) {
		if (!self.isSea) {
			self.armies += count;
			self.armyText.setText(self.armies.toString());
		}
	};
	self.down = function (x, y, obj) {
		if (gameState === 'playing') {
			// Handle ship movement to sea territories
			if (selectedShip && self.isSea) {
				// Allow movement to any sea territory
				if (self.isSea) {
					// Move ship to any sea territory
					selectedShip.x = self.x;
					selectedShip.y = self.y;
					selectedShip.selected = false;
					selectedShip.shipGraphics.tint = 0x27ae60; // Reset color
					// Remove all sea highlights after move
					for (var i = 0; i < territories.length; i++) {
						if (territories[i].isSea && territories[i].showAsTarget) {
							territories[i].showAsTarget = false;
							territories[i].updateGraphics();
						}
					}
					selectedShip = null;
					endPlayerTurn();
					return;
				}
			}
			// Handle ship colonization of distant territories
			if (selectedShip && self.isColonizable && self.owner === 0 && !self.isSea) {
				// Check if ship is close enough to colonize (must be adjacent or very close)
				var distance = Math.abs(selectedShip.x - self.x) + Math.abs(selectedShip.y - self.y);
				if (distance <= territorySpacing * 1.5) {
					// Colonize the territory
					self.setOwner(selectedShip.owner, 2); // Give it 2 armies
					self.isColonizable = false; // No longer colonizable
					if (selectedShip.owner === 1) {
						// Player gets money reward for colonization
						playerMoney += self.colonizationReward;
						if (playerMoneyText) {
							playerMoneyText.setText("Money: " + playerMoney);
						}
						if (instructionText) {
							instructionText.setText("Island colonized! Gained $" + self.colonizationReward);
						}
					}
					LK.getSound('capture').play();
					selectedShip.selected = false;
					selectedShip.shipGraphics.tint = 0x27ae60; // Reset color
					selectedShip = null;
					updateTerritoryCount();
					endPlayerTurn();
					return;
				} else {
					if (instructionText && selectedShip.owner === 1) {
						instructionText.setText("Ship must be closer to colonize this island");
					}
				}
			}
			// Allow colonization of colonizable territory with armies (if adjacent and enough armies)
			if (!self.isSea && self.isColonizable && self.owner === 0 && selectedTerritory && selectedTerritory.owner === 1 && !selectedTerritory.isSea) {
				// Must be adjacent
				var neighbors = getNeighbors(self);
				var isNeighbor = false;
				for (var i = 0; i < neighbors.length; i++) {
					if (neighbors[i] === selectedTerritory) {
						isNeighbor = true;
						break;
					}
				}
				if (isNeighbor && selectedTerritory.armies > 1) {
					// Colonize with armies: move 2 armies, leave at least 1 behind
					self.setOwner(1, 2);
					self.isColonizable = false;
					selectedTerritory.armies -= 2;
					selectedTerritory.armyText.setText(selectedTerritory.armies.toString());
					playerMoney += self.colonizationReward;
					if (playerMoneyText) {
						playerMoneyText.setText("Money: " + playerMoney);
					}
					if (instructionText) {
						instructionText.setText("Island colonized with armies! Gained $" + self.colonizationReward);
					}
					LK.getSound('capture').play();
					updateTerritoryCount();
					endPlayerTurn();
					return;
				} else if (isNeighbor && selectedTerritory.armies <= 1) {
					if (instructionText) {
						instructionText.setText("Need at least 2 armies to colonize with armies!");
					}
					return;
				}
			}
			selectTerritory(self);
		} else if (gameState === 'selectingTarget' && self.showAsTarget) {
			executeAttack(self);
		}
	};
	return self;
});

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

/**** 
* Game Code
****/ 
// Difficulty selection
var selectedDifficulty = null; // "easy", "medium", "hard"
var difficultyButtons = [];
var difficultyText = null;
// Game state variables
// Territory and game assets
var gameState = 'playing'; // 'playing', 'gameOver', 'victory', 'selectingTarget'
var attackTargets = []; // Available targets for attack
var currentTurn = 1; // 1 = player, 2 = enemy
var selectedTerritory = null;
var territories = [];
var playerTerritories = 0;
var enemyTerritories = 0;
var totalTerritories = 0;
var playerMoney = 100; // Starting money
var aiMoney = 100; // Starting AI money
var incomePerTerritory = 10; // Money generated per territory per turn
// Diplomacy variables
var warDeclarations = {}; // Track which countries we're at war with
var diplomacyPanel = null;
// Ship variables
var ships = [];
var selectedShip = null;
// Power selection variables
var selectedAttackPower = 1;
var maxAttackPower = 1;
var powerSelectionMode = false;
// UI elements
var turnText, scoreText, instructionText, playerArmyText, playerMoneyText;
var turnCounterText; // Display for turn counter
var powerText, powerDownButton, powerUpButton;
var actionButtons = [];
// Game settings
var mapWidth = 8;
var mapHeight = 12;
var territorySpacing = 140;
var startX = 2048 / 2 - mapWidth * territorySpacing / 2 + territorySpacing / 2;
var startY = 300;
// Create the game map
function createMap() {
	var id = 0;
	// We'll store adjacency for sea territories here
	var seaAdjacency = {};
	// Create contiguous regions for each country with sea territories
	// Divide the map into regions for 6 countries
	for (var row = 0; row < mapHeight; row++) {
		for (var col = 0; col < mapWidth; col++) {
			var x = startX + col * territorySpacing;
			var y = startY + row * territorySpacing;
			var isSea = false;
			var owner = 0; // default to neutral/sea
			// Create sea lanes (vertical strips)
			if (col === 2 || col === 5) {
				isSea = true;
				owner = 0; // Neutral sea
			} else {
				// Determine owner based on map regions to create contiguous countries
				if (row < mapHeight / 3) {
					// Top third - countries 1 and 2
					if (col < mapWidth / 2) {
						owner = 1; // Country 1 (Green) - top left
					} else {
						owner = 2; // Country 2 (Red) - top right
					}
				} else if (row < mapHeight * 2 / 3) {
					// Middle third - countries 3 and 4
					if (col < mapWidth / 2) {
						owner = 3; // Country 3 (Blue) - middle left
					} else {
						owner = 4; // Country 4 (Purple) - middle right
					}
				} else {
					// Bottom third - countries 5 and 6
					if (col < mapWidth / 2) {
						owner = 5; // Country 5 (Orange) - bottom left
					} else {
						owner = 6; // Country 6 (Cyan) - bottom right
					}
				}
				// If no specific owner assigned, make it sea
				if (owner === 0 && !isSea) {
					isSea = true;
				}
			}
			var territory = new Territory();
			territory.init(id, x, y, owner, isSea);
			territories.push(territory);
			game.addChild(territory);
			id++;
		}
	}
	// Build adjacency for sea territories (by index)
	for (var i = 0; i < territories.length; i++) {
		if (territories[i].isSea) {
			var neighbors = getNeighbors(territories[i]);
			seaAdjacency[i] = [];
			for (var j = 0; j < neighbors.length; j++) {
				if (neighbors[j].isSea) {
					var neighborIndex = territories.indexOf(neighbors[j]);
					if (neighborIndex !== -1) {
						seaAdjacency[i].push(neighborIndex);
					}
				}
			}
		}
	}
	// Attach adjacency info to each sea territory for easy access
	for (var i = 0; i < territories.length; i++) {
		if (territories[i].isSea) {
			territories[i].adjacentSeaIndices = seaAdjacency[i];
		}
	}
	// Add colonizable territories (distant islands) based on map layout
	// We'll add 3 colonizable islands: one near the top, one near the middle, one near the bottom, in the sea columns
	var colonizableIslands = [{
		col: 2,
		row: 1,
		reward: 80
	}, {
		col: 5,
		row: Math.floor(mapHeight / 2),
		reward: 100
	}, {
		col: 2,
		row: mapHeight - 2,
		reward: 120
	}];
	for (var i = 0; i < colonizableIslands.length; i++) {
		var island = colonizableIslands[i];
		var x = startX + island.col * territorySpacing;
		var y = startY + island.row * territorySpacing;
		var territory = new Territory();
		territory.init(territories.length, x, y, 0, false);
		territory.isColonizable = true;
		territory.colonizationReward = island.reward;
		// Set 5 armies for colonizable territories
		territory.armies = 5;
		if (territory.armyText) {
			territory.armyText.setText("5");
		}
		territory.updateGraphics();
		territories.push(territory);
		game.addChild(territory);
	}
	// Create initial ships for player and enemy
	createShips();
	updateTerritoryCount();
}
// Create initial ships
function createShips() {
	// Find sea territories for ship placement
	var seaTerritories = [];
	for (var i = 0; i < territories.length; i++) {
		if (territories[i].isSea) {
			seaTerritories.push(territories[i]);
		}
	}
	// Place initial ships
	if (seaTerritories.length > 0) {
		// Player ship - automatically select it to start on the ship
		var playerShip = new Ship();
		var playerSeaPos = seaTerritories[Math.floor(Math.random() * seaTerritories.length)];
		playerShip.init(1, playerSeaPos.x, playerSeaPos.y);
		ships.push(playerShip);
		// Auto-select the player ship so they start on it
		selectShip(playerShip);
		// Enemy ship
		var enemyShip = new Ship();
		var enemySeaPos = seaTerritories[Math.floor(Math.random() * seaTerritories.length)];
		enemyShip.init(2, enemySeaPos.x, enemySeaPos.y);
		ships.push(enemyShip);
		// Ensure ships are always rendered above sea territories by adding them after all territories are added
		game.addChild(playerShip);
		game.addChild(enemyShip);
	}
}
// Ship selection
function selectShip(ship) {
	if (selectedDifficulty === null) return;
	if (currentTurn !== 1) return;
	// Deselect previous selections
	if (selectedTerritory) {
		selectedTerritory.selected = false;
		selectedTerritory.updateGraphics();
		selectedTerritory = null;
	}
	if (selectedShip) {
		selectedShip.selected = false;
		selectedShip.shipGraphics.tint = 0x27ae60; // Reset to green
	}
	// Select new ship
	selectedShip = ship;
	ship.selected = true;
	ship.shipGraphics.tint = 0xf1c40f; // Yellow when selected
	// Remove all possible move highlights when selecting a ship, only show on click
	for (var i = 0; i < territories.length; i++) {
		if (territories[i].isSea) {
			territories[i].showAsTarget = false;
			territories[i].updateGraphics();
		}
	}
	// Do not show possible moves here; will be shown on ship click (down event)
	hidePowerSelection();
	updateInstructions();
}
// Generate income based on territories owned
function generateIncome() {
	var income = playerTerritories * incomePerTerritory;
	playerMoney += income;
	if (playerMoneyText) {
		playerMoneyText.setText("Money: " + playerMoney + " (+$" + income + ")");
	}
}
// Update territory ownership counts
function updateTerritoryCount() {
	playerTerritories = 0;
	enemyTerritories = 0;
	var playerTotalArmies = 0;
	var country1Count = 0,
		country2Count = 0,
		country3Count = 0;
	var country4Count = 0,
		country5Count = 0,
		country6Count = 0;
	totalTerritories = territories.length;
	for (var i = 0; i < territories.length; i++) {
		if (territories[i].owner === 1) {
			playerTerritories++;
			country1Count++;
			playerTotalArmies += territories[i].armies;
		} else if (territories[i].owner === 2) {
			enemyTerritories++;
			country2Count++;
		} else if (territories[i].owner === 3) {
			country3Count++;
		} else if (territories[i].owner === 4) {
			country4Count++;
		} else if (territories[i].owner === 5) {
			country5Count++;
		} else if (territories[i].owner === 6) {
			country6Count++;
		}
	}
	// Update score display
	if (scoreText) {
		scoreText.setText("Countries - Green: " + country1Count + " | Red: " + country2Count + " | Blue: " + country3Count + " | Purple: " + country4Count + " | Orange: " + country5Count + " | Cyan: " + country6Count);
	}
	// Update player army display
	if (playerArmyText) {
		playerArmyText.setText("Total Armies: " + playerTotalArmies);
	}
	// Update money display
	if (playerMoneyText) {
		playerMoneyText.setText("Money: " + playerMoney);
	}
	// Check victory conditions
	if (playerTerritories >= Math.floor(totalTerritories * 0.75)) {
		gameState = 'victory';
		LK.showYouWin();
	} else if (enemyTerritories >= Math.floor(totalTerritories * 0.75)) {
		gameState = 'gameOver';
		LK.showGameOver();
	}
}
// Declare war function
function declareWar(countryId) {
	warDeclarations[countryId] = true;
	if (instructionText) {
		instructionText.setText("War declared on Country " + countryId + "! You can now attack their territories.");
	}
}
// Territory selection
function selectTerritory(territory) {
	if (selectedDifficulty === null) return;
	if (currentTurn !== 1) return; // Only during player turn
	// If we're in target selection mode, cancel it
	if (gameState === 'selectingTarget') {
		// Clear target highlighting
		for (var i = 0; i < attackTargets.length; i++) {
			attackTargets[i].showAsTarget = false;
			attackTargets[i].updateGraphics();
		}
		gameState = 'playing';
		attackTargets = [];
	}
	// Deselect previous territory
	if (selectedTerritory) {
		selectedTerritory.selected = false;
		selectedTerritory.updateGraphics();
		// Ensure previous territory's army text remains visible
		selectedTerritory.armyText.setText(selectedTerritory.armies.toString());
		// Re-add army text to ensure it's visible
		selectedTerritory.removeChild(selectedTerritory.armyText);
		selectedTerritory.addChild(selectedTerritory.armyText);
	}
	// Handle enemy territory clicks - show diplomacy panel
	if (territory.owner !== 1 && territory.owner !== 0) {
		// Create diplomacy panel if it doesn't exist
		if (!diplomacyPanel) {
			diplomacyPanel = new DiplomacyPanel();
			diplomacyPanel.init(territory.owner);
		} else {
			// Update existing panel for new country
			diplomacyPanel.targetCountry = territory.owner;
			diplomacyPanel.titleText.setText("Diplomacy with Country " + territory.owner);
		}
		diplomacyPanel.show();
		return;
	}
	// Select new territory
	if (territory.owner === 1) {
		// Only select player territories
		selectedTerritory = territory;
		territory.selected = true;
		territory.updateGraphics();
		// Ensure army text is visible and updated
		territory.armyText.setText(territory.armies.toString());
		// Bring army text to front to ensure it's visible
		territory.removeChild(territory.armyText);
		territory.addChild(territory.armyText);
		// Show power selection for territories with armies > 1
		if (!territory.isSea && territory.armies > 1) {
			showPowerSelection(territory.armies - 1);
		} else {
			hidePowerSelection();
		}
		updateInstructions();
	} else {
		hidePowerSelection();
	}
}
// Get neighboring territories
function getNeighbors(territory) {
	var neighbors = [];
	var index = territories.indexOf(territory);
	var row = Math.floor(index / mapWidth);
	var col = index % mapWidth;
	// Check all 4 directions
	var directions = [{
		row: -1,
		col: 0
	},
	// up
	{
		row: 1,
		col: 0
	},
	// down
	{
		row: 0,
		col: -1
	},
	// left
	{
		row: 0,
		col: 1
	} // right
	];
	for (var i = 0; i < directions.length; i++) {
		var newRow = row + directions[i].row;
		var newCol = col + directions[i].col;
		if (newRow >= 0 && newRow < mapHeight && newCol >= 0 && newCol < mapWidth) {
			var neighborIndex = newRow * mapWidth + newCol;
			neighbors.push(territories[neighborIndex]);
		}
	}
	return neighbors;
}
// Attack action
function attackTerritory() {
	if (selectedDifficulty === null) return;
	if (!selectedTerritory || selectedTerritory.armies <= 1) return;
	var neighbors = getNeighbors(selectedTerritory);
	var targets = [];
	for (var i = 0; i < neighbors.length; i++) {
		if (neighbors[i].owner !== 1) {
			// Check if we can attack this country (either neutral or at war)
			if (neighbors[i].owner === 0 || warDeclarations[neighbors[i].owner]) {
				targets.push(neighbors[i]);
			}
		}
	}
	if (targets.length > 0) {
		// Show target selection mode
		gameState = 'selectingTarget';
		attackTargets = targets;
		// Highlight all possible targets
		for (var i = 0; i < targets.length; i++) {
			targets[i].showAsTarget = true;
			targets[i].updateGraphics();
		}
		if (instructionText) {
			instructionText.setText("Select a territory to attack");
		}
	}
}
// Execute attack on selected target
function executeAttack(target) {
	if (!selectedTerritory || !target) return;
	// Clear target highlighting
	for (var i = 0; i < attackTargets.length; i++) {
		attackTargets[i].showAsTarget = false;
		attackTargets[i].updateGraphics();
	}
	// Simple combat resolution using selected attack power
	var attackPower = selectedAttackPower;
	var defensePower = target.armies;
	if (attackPower > defensePower) {
		// Victory
		target.setOwner(1, attackPower - defensePower);
		selectedTerritory.armies = selectedTerritory.armies - attackPower;
		selectedTerritory.armyText.setText(selectedTerritory.armies.toString());
		LK.getSound('capture').play();
	} else {
		// Defeat - lose the armies used in attack
		selectedTerritory.armies = selectedTerritory.armies - attackPower;
		selectedTerritory.armyText.setText(selectedTerritory.armies.toString());
		if (defensePower > attackPower) {
			target.armies = defensePower - attackPower;
			target.armyText.setText(target.armies.toString());
		}
	}
	LK.getSound('attack').play();
	updateTerritoryCount();
	// Reset game state
	gameState = 'playing';
	attackTargets = [];
	endPlayerTurn();
}
// Recruit armies action
function recruitArmies() {
	if (selectedDifficulty === null) return;
	if (!selectedTerritory) return;
	var recruitCost = 100; // Increased cost to recruit armies
	if (playerMoney >= recruitCost) {
		playerMoney -= recruitCost;
		selectedTerritory.addArmies(2);
		if (playerMoneyText) {
			playerMoneyText.setText("Money: " + playerMoney);
		}
		endPlayerTurn();
	} else {
		// Not enough money - show feedback but don't end turn
		if (instructionText) {
			instructionText.setText("Not enough money! Need $" + recruitCost + " to recruit");
		}
	}
}
// Build ship action
function buildShip() {
	if (selectedDifficulty === null) return;
	if (!selectedTerritory || selectedTerritory.isSea) return;
	var shipCost = 200; //{4Z} // Increased cost
	// Determine which country's money to use
	var owner = selectedTerritory.owner;
	if (owner === 0 || owner === undefined) return; // Only countries can build ships
	// Only allow if the country has enough money
	var canBuild = false;
	if (owner === 1 && playerMoney >= shipCost) {
		canBuild = true;
	} else if (owner === 2 && aiMoney >= shipCost) {
		canBuild = true;
	} else if (owner > 2) {
		// For AI countries 3-6, give them their own money pool if not present
		if (typeof window['countryMoney' + owner] === "undefined") {
			window['countryMoney' + owner] = 100;
		}
		if (window['countryMoney' + owner] >= shipCost) {
			canBuild = true;
		}
	}
	if (canBuild) {
		// Find adjacent sea territory
		var neighbors = getNeighbors(selectedTerritory);
		var seaNeighbors = [];
		for (var i = 0; i < neighbors.length; i++) {
			if (neighbors[i].isSea) {
				seaNeighbors.push(neighbors[i]);
			}
		}
		if (seaNeighbors.length > 0) {
			// Deduct money from the correct pool
			if (owner === 1) {
				playerMoney -= shipCost;
			} else if (owner === 2) {
				aiMoney -= shipCost;
			} else if (owner > 2) {
				window['countryMoney' + owner] -= shipCost;
			}
			var seaPos = seaNeighbors[0];
			var newShip = new Ship();
			newShip.init(owner, seaPos.x, seaPos.y);
			ships.push(newShip);
			// Ensure new ships are rendered above sea territories
			game.addChild(newShip);
			if (owner === 1 && playerMoneyText) {
				playerMoneyText.setText("Money: " + playerMoney);
			}
			endPlayerTurn();
		} else {
			if (instructionText && owner === 1) {
				instructionText.setText("No adjacent sea territory to build ship!");
			}
		}
	} else {
		if (instructionText && owner === 1) {
			instructionText.setText("Not enough money! Need $" + shipCost + " to build ship");
		}
	}
}
// Naval combat
function navalCombat(attackerShip, defenderShip) {
	var damage = 1;
	var defenderDestroyed = defenderShip.takeDamage(damage);
	if (defenderDestroyed) {
		// Remove destroyed ship
		var index = ships.indexOf(defenderShip);
		if (index > -1) {
			ships.splice(index, 1);
		}
		defenderShip.destroy();
		LK.getSound('capture').play();
	} else {
		LK.getSound('attack').play();
	}
}
// Per-country ship build timers for AI countries 3-6
var countryShipTimers = {};
// Per-country war declaration timers for AI countries 2-6 (enemy and other AIs)
var countryWarTimers = {};
for (var c = 2; c <= 6; c++) {
	// For war timers: if not at war, 12 turns; if at war, 30 turns (will be set dynamically in aiTurn)
	countryWarTimers[c] = Math.floor(Math.random() * 3) + 10; // randomize initial timer between 10-12
}
for (var c = 3; c <= 6; c++) {
	// Randomize initial timer between 3 and 5
	countryShipTimers[c] = Math.floor(Math.random() * 3) + 3;
}
// End player turn
function endPlayerTurn() {
	if (selectedTerritory) {
		selectedTerritory.selected = false;
		selectedTerritory.updateGraphics();
		selectedTerritory = null;
	}
	hidePowerSelection();
	// Generate income based on territories owned
	generateIncome();
	currentTurn = 2;
	if (turnCounterText) {
		// Only increment turn number at the end of the player's turn
		var turnTextValue = typeof turnCounterText.text === "string" ? turnCounterText.text : turnCounterText.text !== undefined && turnCounterText.text !== null ? String(turnCounterText.text) : "";
		var matches = turnTextValue.match(/\d+/);
		var currentTurnNumber = matches ? parseInt(matches[0], 10) : 1;
		currentTurnNumber++;
		if (currentTurnNumber > 10000) currentTurnNumber = 10000;
		turnCounterText.setText("Turn: " + currentTurnNumber);
	}
	updateInstructions();
	// AI turn after short delay
	LK.setTimeout(function () {
		aiTurn();
	}, 1000);
}
// Helper: AI build ship for a country if possible
function aiBuildShipForCountry(countryId) {
	// Find all territories owned by this country
	var owned = [];
	for (var i = 0; i < territories.length; i++) {
		if (territories[i].owner === countryId && !territories[i].isSea) {
			owned.push(territories[i]);
		}
	}
	// Try to build ship from a random owned territory with adjacent sea
	if (owned.length > 0) {
		var t = owned[Math.floor(Math.random() * owned.length)];
		var neighbors = getNeighbors(t);
		var seaNeighbors = [];
		for (var j = 0; j < neighbors.length; j++) {
			if (neighbors[j].isSea) seaNeighbors.push(neighbors[j]);
		}
		if (seaNeighbors.length > 0) {
			// Deduct money if needed (handled in buildShip, but we do it here for AI)
			if (typeof window['countryMoney' + countryId] === "undefined") {
				window['countryMoney' + countryId] = 100;
			}
			var shipCost = 200;
			if (window['countryMoney' + countryId] >= shipCost) {
				window['countryMoney' + countryId] -= shipCost;
				var seaPos = seaNeighbors[0];
				var newShip = new Ship();
				newShip.init(countryId, seaPos.x, seaPos.y);
				ships.push(newShip);
				game.addChild(newShip);
				return true;
			}
		}
	}
	return false;
}
// Simple AI turn
function aiTurn() {
	// Generate AI income
	var aiIncome = enemyTerritories * incomePerTerritory;
	aiMoney += aiIncome;
	var enemyTerrs = [];
	for (var i = 0; i < territories.length; i++) {
		if (territories[i].owner === 2) {
			enemyTerrs.push(territories[i]);
		}
	}
	if (enemyTerrs.length > 0) {
		var aiTerritory = enemyTerrs[Math.floor(Math.random() * enemyTerrs.length)];
		var neighbors = getNeighbors(aiTerritory);
		var playerTargets = [];
		// In easy mode, AI never attacks
		if (selectedDifficulty === "easy") {
			// AI does not attack, just does economy/ship/army actions below
			playerTargets = [];
		} else {
			for (var j = 0; j < neighbors.length; j++) {
				// AI can attack player territories if war is declared on AI (country 2)
				if (neighbors[j].owner === 1 && warDeclarations[2]) {
					playerTargets.push(neighbors[j]);
				}
			}
		}
		if (playerTargets.length > 0 && aiTerritory.armies > 1) {
			// AI attacks
			var target = playerTargets[Math.floor(Math.random() * playerTargets.length)];
			var attackPower = aiTerritory.armies - 1;
			var defensePower = target.armies;
			if (attackPower > defensePower) {
				target.setOwner(2, attackPower - defensePower);
				aiTerritory.armies = 1;
				aiTerritory.armyText.setText(aiTerritory.armies.toString());
			} else {
				aiTerritory.armies = 1;
				aiTerritory.armyText.setText(aiTerritory.armies.toString());
				if (defensePower > attackPower) {
					target.armies = defensePower - attackPower;
					target.armyText.setText(target.armies.toString());
				}
			}
		} else {
			// AI decides what to do based on money and strategy
			var action = Math.random();
			var recruitCost = 50;
			var shipCost = 100;
			if (action < 0.4 && aiMoney >= recruitCost) {
				// 40% chance to recruit armies if affordable
				aiMoney -= recruitCost;
				aiTerritory.addArmies(2);
			} else if (action < 0.7 && aiMoney >= shipCost) {
				// 30% chance to build ship if possible and affordable
				var seaNeighbors = [];
				for (var k = 0; k < neighbors.length; k++) {
					if (neighbors[k].isSea) {
						seaNeighbors.push(neighbors[k]);
					}
				}
				if (seaNeighbors.length > 0) {
					// Build ship in adjacent sea
					aiMoney -= shipCost;
					var seaPos = seaNeighbors[0];
					var newShip = new Ship();
					newShip.init(2, seaPos.x, seaPos.y);
					ships.push(newShip);
					// Ensure AI ships are rendered above sea territories
					game.addChild(newShip);
				} else {
					// No sea nearby, recruit if affordable or just add basic army
					if (aiMoney >= recruitCost) {
						aiMoney -= recruitCost;
						aiTerritory.addArmies(2);
					} else {
						aiTerritory.addArmies(1);
					}
				}
			} else {
				// Default action - add basic army (free)
				aiTerritory.addArmies(1);
			}
		}
	}
	// AI war declaration logic for hard difficulty
	if (selectedDifficulty === "hard") {
		// AI countries 2-6 may declare war more frequently
		for (var c = 2; c <= 6; c++) {
			// Only consider declaring war on countries we are not already at war with
			if (!warDeclarations[c]) {
				countryWarTimers[c]--;
				if (countryWarTimers[c] <= 0) {
					// Declare war on a random other country (not self)
					var possibleTargets = [];
					for (var t = 1; t <= 6; t++) {
						if (t !== c && !warDeclarations[t]) {
							possibleTargets.push(t);
						}
					}
					if (possibleTargets.length > 0) {
						var target = possibleTargets[Math.floor(Math.random() * possibleTargets.length)];
						warDeclarations[target] = true;
						// Optionally, show a message if the player is the target
						if (target === 1 && instructionText) {
							instructionText.setText("Country " + c + " has declared war on you!");
						}
					}
					// Reset timer for next declaration (12 turns if not at war, 30 if at war)
					if (warDeclarations[c]) {
						countryWarTimers[c] = 30;
					} else {
						countryWarTimers[c] = 12;
					}
				}
			} else {
				// If already at war, use longer timer before next declaration
				countryWarTimers[c]--;
				if (countryWarTimers[c] <= 0) {
					// Try to declare war on another country (not self, not already at war)
					var possibleTargets = [];
					for (var t = 1; t <= 6; t++) {
						if (t !== c && !warDeclarations[t]) {
							possibleTargets.push(t);
						}
					}
					if (possibleTargets.length > 0) {
						var target = possibleTargets[Math.floor(Math.random() * possibleTargets.length)];
						warDeclarations[target] = true;
						if (target === 1 && instructionText) {
							instructionText.setText("Country " + c + " has declared war on you!");
						}
					}
					// Reset timer for next declaration (30 turns if at war)
					countryWarTimers[c] = 30;
				}
			}
		}
	}
	// In easy mode, AI never declares war (handled by not attacking above)
	// AI countries 3-6: build ships every 3-5 turns if possible
	for (var c = 3; c <= 6; c++) {
		if (typeof countryShipTimers[c] === "undefined") {
			countryShipTimers[c] = Math.floor(Math.random() * 3) + 3;
		}
		countryShipTimers[c]--;
		if (countryShipTimers[c] <= 0) {
			var built = aiBuildShipForCountry(c);
			// Reset timer regardless of success, so they try again in 3-5 turns
			countryShipTimers[c] = Math.floor(Math.random() * 3) + 3;
		}
	}
	// AI ship movement and naval combat
	var aiShips = [];
	for (var i = 0; i < ships.length; i++) {
		if (ships[i].owner === 2) {
			aiShips.push(ships[i]);
		}
	}
	if (aiShips.length > 0) {
		var aiShip = aiShips[Math.floor(Math.random() * aiShips.length)];
		// Look for player ships to attack
		var playerShips = [];
		for (var i = 0; i < ships.length; i++) {
			if (ships[i].owner === 1) {
				var distance = Math.abs(ships[i].x - aiShip.x) + Math.abs(ships[i].y - aiShip.y);
				if (distance < 200) {
					// Close enough to attack
					playerShips.push(ships[i]);
				}
			}
		}
		if (playerShips.length > 0) {
			// Attack nearest player ship
			var target = playerShips[0];
			navalCombat(aiShip, target);
		} else {
			// Look for colonizable territories
			var colonizableTargets = [];
			for (var i = 0; i < territories.length; i++) {
				if (territories[i].isColonizable && territories[i].owner === 0 && !territories[i].isSea) {
					var distance = Math.abs(territories[i].x - aiShip.x) + Math.abs(territories[i].y - aiShip.y);
					if (distance <= territorySpacing * 1.5) {
						colonizableTargets.push(territories[i]);
					}
				}
			}
			if (colonizableTargets.length > 0) {
				// Colonize nearest available territory
				var target = colonizableTargets[0];
				target.setOwner(2, 2);
				target.isColonizable = false; // No longer colonizable
				aiMoney += target.colonizationReward;
			} else {
				// Move to random sea territory or towards colonizable islands
				var moveTargets = [];
				// Add sea territories
				for (var i = 0; i < territories.length; i++) {
					if (territories[i].isSea) {
						moveTargets.push(territories[i]);
					}
				}
				// Add positions near colonizable islands
				for (var i = 0; i < territories.length; i++) {
					if (territories[i].isColonizable && territories[i].owner === 0) {
						moveTargets.push(territories[i]);
					}
				}
				if (moveTargets.length > 0) {
					var newPos = moveTargets[Math.floor(Math.random() * moveTargets.length)];
					aiShip.x = newPos.x;
					aiShip.y = newPos.y;
				}
			}
		}
	}
	updateTerritoryCount();
	currentTurn = 1;
	updateInstructions();
}
// Create UI elements
function createUI() {
	// Turn indicator
	turnText = new Text2("Your Turn", {
		size: 40,
		fill: 0xFFFFFF
	});
	turnText.anchor.set(0.5, 0);
	LK.gui.top.addChild(turnText);
	turnText.y = 100;
	if (turnCounterText) {
		turnCounterText.setText("Turn: 1");
	}
	// Turn counter (top right, avoid top left 100x100)
	turnCounterText = new Text2("Turn: 1", {
		size: 36,
		fill: 0xffffff
	});
	turnCounterText.anchor.set(1, 0); // right-top
	LK.gui.topRight.addChild(turnCounterText);
	turnCounterText.x = 0;
	turnCounterText.y = 0;
	// Score display
	scoreText = new Text2("Player: 0 | Enemy: 0", {
		size: 32,
		fill: 0xFFFFFF
	});
	scoreText.anchor.set(0.5, 0);
	LK.gui.top.addChild(scoreText);
	scoreText.y = 150;
	// Player army count display
	playerArmyText = new Text2("Total Armies: 0", {
		size: 32,
		fill: 0x7ed321
	});
	playerArmyText.anchor.set(0.5, 0);
	LK.gui.top.addChild(playerArmyText);
	playerArmyText.y = 190;
	// Player money display
	playerMoneyText = new Text2("Money: " + playerMoney, {
		size: 32,
		fill: 0xf5a623
	});
	playerMoneyText.anchor.set(0.5, 0);
	LK.gui.top.addChild(playerMoneyText);
	playerMoneyText.y = 230;
	// Instructions
	instructionText = new Text2("Select your territory, then choose an action", {
		size: 28,
		fill: 0xFFFFFF
	});
	instructionText.anchor.set(0.5, 1);
	LK.gui.bottom.addChild(instructionText);
	instructionText.y = -200;
	// Action buttons
	var attackBtn = new ActionButton();
	attackBtn.init("Attack", attackTerritory, 2048 / 2 - 200, 2732 - 120);
	actionButtons.push(attackBtn);
	game.addChild(attackBtn);
	var recruitBtn = new ActionButton();
	recruitBtn.init("Recruit", recruitArmies, 2048 / 2 - 60, 2732 - 120);
	actionButtons.push(recruitBtn);
	game.addChild(recruitBtn);
	var buildShipBtn = new ActionButton();
	buildShipBtn.init("Build Ship", buildShip, 2048 / 2 + 80, 2732 - 120);
	actionButtons.push(buildShipBtn);
	game.addChild(buildShipBtn);
	// Skip Turn button
	var skipTurnBtn = new ActionButton();
	skipTurnBtn.init("Skip Turn", function () {
		if (selectedDifficulty === null) return;
		if (currentTurn === 1) {
			endPlayerTurn();
		}
	}, 2048 / 2 + 220, 2732 - 120);
	actionButtons.push(skipTurnBtn);
	game.addChild(skipTurnBtn);
	// Power selection display
	powerText = new Text2("Attack Power: 1/1", {
		size: 28,
		fill: 0xffff00
	});
	powerText.anchor.set(0.5, 1);
	LK.gui.bottom.addChild(powerText);
	powerText.y = -240;
	powerText.visible = false;
	// Power adjustment buttons
	var powerDownBtn = new ActionButton();
	powerDownBtn.init("-", decreasePower, 2048 / 2 - 100, 2732 - 180);
	actionButtons.push(powerDownBtn);
	game.addChild(powerDownBtn);
	powerDownBtn.visible = false;
	var powerUpBtn = new ActionButton();
	powerUpBtn.init("+", increasePower, 2048 / 2 + 100, 2732 - 180);
	actionButtons.push(powerUpBtn);
	game.addChild(powerUpBtn);
	powerUpBtn.visible = false;
	// Store power buttons for visibility control
	powerDownButton = powerDownBtn;
	powerUpButton = powerUpBtn;
}
// Power selection functions
function decreasePower() {
	if (selectedDifficulty === null) return;
	if (selectedAttackPower > 1) {
		selectedAttackPower--;
		updatePowerDisplay();
	}
}
function increasePower() {
	if (selectedDifficulty === null) return;
	if (selectedAttackPower < maxAttackPower) {
		selectedAttackPower++;
		updatePowerDisplay();
	}
}
function updatePowerDisplay() {
	if (powerText) {
		powerText.setText("Attack Power: " + selectedAttackPower + "/" + maxAttackPower);
	}
}
function showPowerSelection(maxPower) {
	maxAttackPower = maxPower;
	selectedAttackPower = Math.min(selectedAttackPower, maxAttackPower);
	powerSelectionMode = true;
	if (powerText) {
		powerText.visible = true;
		updatePowerDisplay();
	}
	if (powerDownButton && powerUpButton) {
		powerDownButton.visible = true;
		powerUpButton.visible = true;
	}
}
function hidePowerSelection() {
	powerSelectionMode = false;
	if (powerText) {
		powerText.visible = false;
	}
	if (powerDownButton && powerUpButton) {
		powerDownButton.visible = false;
		powerUpButton.visible = false;
	}
}
// Update instruction text
function updateInstructions() {
	if (selectedDifficulty === null) {
		if (instructionText) {
			instructionText.setText("Please select a difficulty (Easy, Medium, Hard)");
		}
		return;
	}
	if (currentTurn === 1) {
		if (turnText) {
			turnText.setText("Your Turn");
		}
		if (instructionText) {
			if (selectedShip) {
				instructionText.setText("Ship selected - Move to sea or attack enemy ships");
			} else if (selectedTerritory) {
				if (selectedTerritory.isSea) {
					instructionText.setText("Sea territory selected - Ships can move here");
				} else if (powerSelectionMode) {
					instructionText.setText("Use +/- to choose attack power, then Attack, Recruit ($100), or Build Ship ($200)");
				} else {
					instructionText.setText("Territory selected - Attack, Recruit ($100), or Build Ship ($200)");
				}
			} else {
				instructionText.setText("Select your territory/ship (green), then choose an action");
			}
		}
	} else {
		if (turnText) {
			turnText.setText("Enemy Turn");
		}
		if (instructionText) {
			instructionText.setText("Enemy is thinking...");
		}
	}
}
// Game update loop for naval combat highlighting
game.update = function () {
	// Highlight enemy ships in combat range when player ship is selected
	if (selectedShip && selectedShip.owner === 1) {
		for (var i = 0; i < ships.length; i++) {
			if (ships[i].owner === 2) {
				var distance = Math.abs(selectedShip.x - ships[i].x) + Math.abs(selectedShip.y - ships[i].y);
				if (distance < 200) {
					// Highlight enemy ship in range
					ships[i].shipGraphics.tint = 0xff6b6b; // Red tint for attackable
				} else {
					ships[i].shipGraphics.tint = 0xe74c3c; // Default red for enemy
				}
			}
		}
	} else {
		// Reset all ship colors when no ship selected
		for (var i = 0; i < ships.length; i++) {
			if (ships[i].owner === 2) {
				ships[i].shipGraphics.tint = 0xe74c3c; // Default red for enemy
			} else if (ships[i].owner === 1 && ships[i] !== selectedShip) {
				ships[i].shipGraphics.tint = 0x27ae60; // Default green for player
			}
		}
	}
};
// Difficulty selection UI
function showDifficultySelection() {
	// Block all game actions until difficulty is selected
	gameState = "selectingDifficulty";
	// Hide all action buttons
	for (var i = 0; i < actionButtons.length; i++) {
		actionButtons[i].visible = false;
	}
	// Hide power selection
	hidePowerSelection();
	// Create a full-screen overlay container for difficulty selection
	if (typeof difficultyOverlay !== "undefined" && difficultyOverlay.parent) {
		difficultyOverlay.parent.removeChild(difficultyOverlay);
	}
	difficultyOverlay = new Container();
	difficultyOverlay.x = 0;
	difficultyOverlay.y = 0;
	// Add a semi-transparent background to block game interaction
	var overlayBg = LK.getAsset('actionButton', {
		anchorX: 0,
		anchorY: 0,
		scaleX: 2048 / 180,
		scaleY: 2732 / 60
	});
	overlayBg.alpha = 0.85;
	overlayBg.tint = 0x222222;
	difficultyOverlay.addChild(overlayBg);
	// Show difficulty selection text
	difficultyText = new Text2("Select Difficulty", {
		size: 60,
		fill: 0xffffff
	});
	difficultyText.anchor.set(0.5, 0.5);
	difficultyText.x = 2048 / 2;
	difficultyText.y = 2732 / 2 - 200;
	difficultyOverlay.addChild(difficultyText);
	// Button positions
	var btnY = 2732 / 2;
	var btnSpacing = 220;
	var btnLabels = [{
		label: "Easy",
		value: "easy"
	}, {
		label: "Medium",
		value: "medium"
	}, {
		label: "Hard",
		value: "hard"
	}];
	for (var i = 0; i < btnLabels.length; i++) {
		var btn = new ActionButton();
		btn.init(btnLabels[i].label, function (difficulty) {
			return function () {
				selectDifficulty(difficulty);
			};
		}(btnLabels[i].value), 2048 / 2 + (i - 1) * btnSpacing, btnY);
		difficultyButtons.push(btn);
		difficultyOverlay.addChild(btn);
	}
	// Add overlay to game
	game.addChild(difficultyOverlay);
}
// Remove difficulty selection UI and start the game
function selectDifficulty(difficulty) {
	selectedDifficulty = difficulty;
	// Remove difficulty UI overlay
	if (typeof difficultyOverlay !== "undefined" && difficultyOverlay.parent) {
		difficultyOverlay.parent.removeChild(difficultyOverlay);
	}
	difficultyButtons = [];
	// Show action buttons
	for (var i = 0; i < actionButtons.length; i++) {
		actionButtons[i].visible = true;
	}
	// Set game state to playing and update UI
	gameState = "playing";
	updateInstructions();
}
// Initialize the game
createMap();
createUI();
showDifficultySelection();
updateInstructions();

===================================================================
--- original.js
+++ change.js
@@ -882,9 +882,10 @@
 	currentTurn = 2;
 	if (turnCounterText) {
 		// Only increment turn number at the end of the player's turn
 		var turnTextValue = typeof turnCounterText.text === "string" ? turnCounterText.text : turnCounterText.text !== undefined && turnCounterText.text !== null ? String(turnCounterText.text) : "";
-		var currentTurnNumber = parseInt(turnTextValue.replace(/\D/g, "")) || 1;
+		var matches = turnTextValue.match(/\d+/);
+		var currentTurnNumber = matches ? parseInt(matches[0], 10) : 1;
 		currentTurnNumber++;
 		if (currentTurnNumber > 10000) currentTurnNumber = 10000;
 		turnCounterText.setText("Turn: " + currentTurnNumber);
 	}