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

/**** 
* Classes
****/ 
var GridTile = Container.expand(function (gridX, gridY) {
	var self = Container.call(this);
	self.gridX = gridX;
	self.gridY = gridY;
	self.unit = null;
	self.hasTerrain = false;
	var tileGraphics = self.attachAsset('gridTile', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	var highlightGraphics = self.attachAsset('highlightTile', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	highlightGraphics.alpha = 0;
	var attackGraphics = self.attachAsset('attackTile', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	attackGraphics.alpha = 0;
	self.showHighlight = function () {
		highlightGraphics.alpha = 0.4;
		attackGraphics.alpha = 0;
	};
	self.showAttackRange = function () {
		attackGraphics.alpha = 0.5;
		highlightGraphics.alpha = 0;
	};
	self.hideHighlights = function () {
		highlightGraphics.alpha = 0;
		attackGraphics.alpha = 0;
	};
	self.terrainType = 'normal'; // normal, tree, water, bridge
	self.addTerrain = function (terrainType) {
		if (!self.hasTerrain) {
			self.terrainType = terrainType || 'normal';
			var assetName = 'terrain';
			if (terrainType === 'tree') assetName = 'tree';else if (terrainType === 'water') assetName = 'water';else if (terrainType === 'bridge') assetName = 'bridge';
			var terrainGraphics = self.attachAsset(assetName, {
				anchorX: 0.5,
				anchorY: 0.5
			});
			terrainGraphics.alpha = 0.8;
			self.hasTerrain = true;
		}
	};
	return self;
});
var Unit = Container.expand(function (type, team, weaponType) {
	var self = Container.call(this);
	self.type = type;
	self.team = team;
	self.weaponType = weaponType;
	self.gridX = 0;
	self.gridY = 0;
	self.hp = 2;
	self.maxHp = self.hp;
	self.attack = 1;
	self.defense = 1;
	self.hasMoved = false;
	self.hasAttacked = false;
	var unitGraphics;
	if (type === 'commander') {
		unitGraphics = self.attachAsset('commander', {
			anchorX: 0.5,
			anchorY: 0.5
		});
	} else if (type === 'rider') {
		unitGraphics = self.attachAsset('rider', {
			anchorX: 0.5,
			anchorY: 0.5
		});
	} else if (type === 'dragonRider') {
		unitGraphics = self.attachAsset('dragonRider', {
			anchorX: 0.5,
			anchorY: 0.5
		});
	} else if (type === 'healer') {
		unitGraphics = self.attachAsset('healer', {
			anchorX: 0.5,
			anchorY: 0.5
		});
	} else if (type === 'armored') {
		unitGraphics = self.attachAsset('armored', {
			anchorX: 0.5,
			anchorY: 0.5
		});
	} else {
		// Use weapon type as sprite
		if (weaponType === 'sword') {
			unitGraphics = self.attachAsset('sword', {
				anchorX: 0.5,
				anchorY: 0.5
			});
		} else if (weaponType === 'bow') {
			unitGraphics = self.attachAsset('bow', {
				anchorX: 0.5,
				anchorY: 0.5
			});
		} else if (weaponType === 'magic') {
			unitGraphics = self.attachAsset('magic', {
				anchorX: 0.5,
				anchorY: 0.5
			});
		} else {
			unitGraphics = self.attachAsset('sword', {
				anchorX: 0.5,
				anchorY: 0.5
			});
		}
	}
	// Add team color filter directly to unit graphics (more opaque, no background)
	if (team === 'player') {
		unitGraphics.tint = 0x5555FF; // Blue tint for player units
	} else {
		unitGraphics.tint = 0xFF5555; // Red tint for enemy units
	}
	// Add commander crown
	if (type === 'commander') {
		var crown = new Text2('♛', {
			size: 25,
			fill: 0xFFD700
		});
		crown.anchor.set(1, 1);
		crown.x = 50;
		crown.y = 50;
		self.addChild(crown);
	}
	var weaponText = new Text2(weaponType === 'sword' ? 'S' : weaponType === 'bow' ? 'B' : weaponType === 'magic' ? 'M' : weaponType === 'rider' ? 'R' : weaponType === 'dragonRider' ? 'D' : weaponType === 'healer' ? 'H' : weaponType === 'armored' ? 'A' : '?', {
		size: 30,
		fill: 0xFFFFFF
	});
	weaponText.anchor.set(0.5, 0.5);
	weaponText.y = -10;
	self.addChild(weaponText);
	var hpText = new Text2(self.hp.toString(), {
		size: 20,
		fill: 0xFFFFFF
	});
	hpText.anchor.set(0.5, 0.5);
	hpText.y = 20;
	self.addChild(hpText);
	self.updateHpDisplay = function () {
		hpText.setText(self.hp.toString());
		if (self.hp <= 0) {
			unitGraphics.alpha = 0.3;
		}
	};
	self.takeDamage = function (damage) {
		var actualDamage = Math.max(1, damage - self.defense);
		if (grid[self.gridY][self.gridX].hasTerrain) {
			actualDamage = Math.max(1, actualDamage - 1);
		}
		self.hp -= actualDamage;
		self.updateHpDisplay();
		return self.hp <= 0;
	};
	self.getRange = function () {
		if (self.weaponType === 'sword') return 1;
		if (self.weaponType === 'bow') return 2;
		if (self.weaponType === 'magic') return 2;
		if (self.weaponType === 'rider') return 1;
		if (self.weaponType === 'dragonRider') return 1;
		if (self.weaponType === 'healer') return 1;
		if (self.weaponType === 'armored') return 1;
		return 1;
	};
	self.getMovementRange = function () {
		if (self.weaponType === 'rider' || self.weaponType === 'dragonRider') return 3;
		if (self.weaponType === 'armored') return 1;
		return 2; // Default movement for sword, bow, magic, healer
	};
	self.canAttack = function (targetX, targetY) {
		var distance = Math.abs(self.gridX - targetX) + Math.abs(self.gridY - targetY);
		if (self.weaponType === 'healer') return false; // Healer cannot attack
		if (self.weaponType === 'bow') {
			return distance === 2; // Bow can only attack at exactly range 2, not adjacent
		}
		return distance <= self.getRange();
	};
	self.canHeal = function (targetX, targetY) {
		if (self.weaponType !== 'healer') return false;
		var distance = Math.abs(self.gridX - targetX) + Math.abs(self.gridY - targetY);
		return distance === 1; // Healer can heal adjacent allies
	};
	self.heal = function (target) {
		if (target.hp < target.maxHp) {
			target.hp += 1;
			if (target.hp > target.maxHp) target.hp = target.maxHp;
			target.updateHpDisplay();
			return true;
		}
		return false;
	};
	self.resetTurn = function () {
		self.hasMoved = false;
		self.hasAttacked = false;
		unitGraphics.alpha = 1.0;
		// Restore original team color
		if (self.team === 'player') {
			unitGraphics.tint = 0x5555FF; // Blue tint for player units
		} else {
			unitGraphics.tint = 0xFF5555; // Red tint for enemy units
		}
	};
	self.endTurn = function () {
		self.hasMoved = true;
		self.hasAttacked = true;
		unitGraphics.alpha = 0.6;
		// Add gray tint for moved allied units
		if (self.team === 'player') {
			unitGraphics.tint = 0x888888; // Gray tint for moved player units
		}
	};
	return self;
});

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

/**** 
* Game Code
****/ 
var GRID_SIZE = 15;
var TILE_SIZE = 128;
var grid = [];
var playerUnits = [];
var enemyUnits = [];
var selectedUnit = null;
var originalUnitPosition = null; // Store original position when moving
var selectedEnemyUnit = null; // Track selected enemy for movement display
var currentTurn = 'player';
var gameState = 'playing';
var turnPhase = 'select'; // 'select', 'move', 'chooseAction', 'attack'
// UI
var turnText = new Text2('Player Turn', {
	size: 60,
	fill: 0xFFFFFF
});
turnText.anchor.set(0.5, 0);
LK.gui.top.addChild(turnText);
var phaseText = new Text2('Select Unit', {
	size: 40,
	fill: 0xFFFFFF
});
phaseText.anchor.set(0.5, 0);
phaseText.y = 80;
LK.gui.top.addChild(phaseText);
// Unit counters
var playerCounter = new Text2('8/8', {
	size: 35,
	fill: 0x5555FF
});
playerCounter.anchor.set(0, 1);
playerCounter.x = 20;
playerCounter.y = -120;
LK.gui.bottomLeft.addChild(playerCounter);
var enemyCounter = new Text2('8/8', {
	size: 35,
	fill: 0xFF5555
});
enemyCounter.anchor.set(1, 1);
enemyCounter.x = -20;
enemyCounter.y = -120;
LK.gui.bottomRight.addChild(enemyCounter);
var endTurnBtn = new Text2('End Turn', {
	size: 50,
	fill: 0x00FF00
});
endTurnBtn.anchor.set(0.5, 1);
LK.gui.bottom.addChild(endTurnBtn);
// botones dinámicos de acción
var attackBtn = null;
var ignoreBtn = null;
function showActionButtons() {
	// Hide end turn button when showing action buttons
	endTurnBtn.alpha = 0;
	endTurnBtn.interactive = false;
	if (selectedUnit.weaponType === 'healer') {
		// Check if there are valid heal targets
		var hasHealTargets = false;
		for (var ty = 0; ty < GRID_SIZE; ty++) {
			for (var tx = 0; tx < GRID_SIZE; tx++) {
				if (selectedUnit.canHeal(tx, ty) && grid[ty][tx].unit && grid[ty][tx].unit.team === selectedUnit.team && grid[ty][tx].unit.hp < grid[ty][tx].unit.maxHp) {
					hasHealTargets = true;
					break;
				}
			}
			if (hasHealTargets) break;
		}
		if (hasHealTargets) {
			attackBtn = new Text2('Heal', {
				size: 50,
				fill: 0x00FF00
			});
			attackBtn.anchor.set(0.5, 1);
			attackBtn.y = -60;
			LK.gui.bottom.addChild(attackBtn);
			attackBtn.interactive = true;
			attackBtn.down = function () {
				turnPhase = 'heal';
				phaseText.setText('Choose ally to heal');
				showHealOptions(selectedUnit);
				removeActionButtons();
			};
		}
	} else {
		attackBtn = new Text2('Attack', {
			size: 50,
			fill: 0xFF0000
		});
		attackBtn.anchor.set(0.5, 1);
		attackBtn.y = -60;
		LK.gui.bottom.addChild(attackBtn);
		attackBtn.interactive = true;
		attackBtn.down = function () {
			turnPhase = 'attack';
			phaseText.setText('Choose enemy to attack');
			showAttackOptions(selectedUnit);
			removeActionButtons();
		};
	}
	ignoreBtn = new Text2('Ignore', {
		size: 50,
		fill: 0xFFFF00
	});
	ignoreBtn.anchor.set(0.5, 1);
	ignoreBtn.y = -10;
	LK.gui.bottom.addChild(ignoreBtn);
	ignoreBtn.interactive = true;
	ignoreBtn.down = function () {
		selectedUnit.endTurn();
		turnPhase = 'select';
		phaseText.setText('Select Unit');
		selectedUnit = null;
		originalUnitPosition = null;
		clearHighlights();
		removeActionButtons();
		// Check if all player units have moved
		checkAutoEndTurn();
	};
}
function removeActionButtons() {
	// Show end turn button again
	if (currentTurn === 'player') {
		endTurnBtn.alpha = 1;
		endTurnBtn.interactive = true;
	}
	if (attackBtn) {
		LK.gui.bottom.removeChild(attackBtn);
		attackBtn = null;
	}
	if (ignoreBtn) {
		LK.gui.bottom.removeChild(ignoreBtn);
		ignoreBtn = null;
	}
}
// Initialize grid
function initializeGrid() {
	var startX = (2048 - GRID_SIZE * TILE_SIZE) / 2;
	var startY = (2732 - GRID_SIZE * TILE_SIZE) / 2;
	for (var y = 0; y < GRID_SIZE; y++) {
		grid[y] = [];
		for (var x = 0; x < GRID_SIZE; x++) {
			var tile = new GridTile(x, y);
			tile.x = startX + x * TILE_SIZE + TILE_SIZE / 2;
			tile.y = startY + y * TILE_SIZE + TILE_SIZE / 2;
			grid[y][x] = tile;
			game.addChild(tile);
		}
	}
	// Generate terrain
	generateTerrain();
}
// Initialize units
function initializeUnits() {
	// Player units (bottom-right corner)
	var playerUnit1 = new Unit('hero', 'player', 'sword');
	placeUnit(playerUnit1, 13, 13);
	playerUnits.push(playerUnit1);
	var playerUnit2 = new Unit('hero', 'player', 'bow');
	placeUnit(playerUnit2, 11, 13);
	playerUnits.push(playerUnit2);
	var playerUnit3 = new Unit('hero', 'player', 'magic');
	placeUnit(playerUnit3, 9, 13);
	playerUnits.push(playerUnit3);
	var playerRider = new Unit('rider', 'player', 'rider');
	placeUnit(playerRider, 14, 12);
	playerUnits.push(playerRider);
	var playerDragonRider = new Unit('dragonRider', 'player', 'dragonRider');
	placeUnit(playerDragonRider, 8, 12);
	playerUnits.push(playerDragonRider);
	var playerHealer = new Unit('healer', 'player', 'healer');
	placeUnit(playerHealer, 10, 14);
	playerUnits.push(playerHealer);
	var playerArmored = new Unit('armored', 'player', 'armored');
	placeUnit(playerArmored, 14, 13);
	playerUnits.push(playerArmored);
	var playerCommander = new Unit('commander', 'player', 'sword');
	placeUnit(playerCommander, 12, 14);
	playerUnits.push(playerCommander);
	// Enemy units (top-left corner)
	var enemyUnit1 = new Unit('hero', 'enemy', 'sword');
	placeUnit(enemyUnit1, 1, 1);
	enemyUnits.push(enemyUnit1);
	var enemyUnit2 = new Unit('hero', 'enemy', 'bow');
	placeUnit(enemyUnit2, 3, 1);
	enemyUnits.push(enemyUnit2);
	var enemyUnit3 = new Unit('hero', 'enemy', 'magic');
	placeUnit(enemyUnit3, 5, 1);
	enemyUnits.push(enemyUnit3);
	var enemyRider = new Unit('rider', 'enemy', 'rider');
	placeUnit(enemyRider, 0, 2);
	enemyUnits.push(enemyRider);
	var enemyDragonRider = new Unit('dragonRider', 'enemy', 'dragonRider');
	placeUnit(enemyDragonRider, 6, 2);
	enemyUnits.push(enemyDragonRider);
	var enemyHealer = new Unit('healer', 'enemy', 'healer');
	placeUnit(enemyHealer, 4, 0);
	enemyUnits.push(enemyHealer);
	var enemyArmored = new Unit('armored', 'enemy', 'armored');
	placeUnit(enemyArmored, 0, 1);
	enemyUnits.push(enemyArmored);
	var enemyCommander = new Unit('commander', 'enemy', 'sword');
	placeUnit(enemyCommander, 2, 0);
	enemyUnits.push(enemyCommander);
}
function generateTerrain() {
	// Add water river in middle of map (rows 6, 7, 8 - 3 tiles wide)
	for (var y = 6; y <= 8; y++) {
		for (var x = 0; x < GRID_SIZE; x++) {
			grid[y][x].addTerrain('water');
		}
	}
	// Add bridges: horizontal pattern (river-bridge-bridge then 9 river tiles then bridge-bridge-river)
	// Bridge 1: columns 1-2, rows 6-8
	for (var y = 6; y <= 8; y++) {
		for (var x = 1; x <= 2; x++) {
			grid[y][x].addTerrain('bridge');
		}
	}
	// Bridge 2: columns 12-13, rows 6-8
	for (var y = 6; y <= 8; y++) {
		for (var x = 12; x <= 13; x++) {
			grid[y][x].addTerrain('bridge');
		}
	}
	// Add some trees scattered around (avoiding bridge areas)
	var treePositions = [{
		x: 4,
		y: 4
	}, {
		x: 6,
		y: 5
	}, {
		x: 9,
		y: 4
	}, {
		x: 11,
		y: 5
	}, {
		x: 3,
		y: 10
	}, {
		x: 5,
		y: 11
	}, {
		x: 8,
		y: 10
	}, {
		x: 10,
		y: 11
	}, {
		x: 7,
		y: 3
	}, {
		x: 14,
		y: 10
	}, {
		x: 0,
		y: 12
	}, {
		x: 14,
		y: 4
	}];
	for (var i = 0; i < treePositions.length; i++) {
		var pos = treePositions[i];
		grid[pos.y][pos.x].addTerrain('tree');
	}
}
function placeUnit(unit, x, y) {
	unit.gridX = x;
	unit.gridY = y;
	unit.x = grid[y][x].x;
	unit.y = grid[y][x].y;
	grid[y][x].unit = unit;
	game.addChild(unit);
}
function clearHighlights() {
	for (var y = 0; y < GRID_SIZE; y++) {
		for (var x = 0; x < GRID_SIZE; x++) {
			grid[y][x].hideHighlights();
		}
	}
}
function showMovementOptions(unit) {
	// Use pathfinding to check reachable tiles considering terrain
	var reachableTiles = getReachableTiles(unit);
	for (var i = 0; i < reachableTiles.length; i++) {
		var tile = reachableTiles[i];
		grid[tile.y][tile.x].showHighlight();
	}
}
function showAttackOptions(unit) {
	for (var y = 0; y < GRID_SIZE; y++) {
		for (var x = 0; x < GRID_SIZE; x++) {
			if (unit.canAttack(x, y) && grid[y][x].unit && grid[y][x].unit.team !== unit.team && grid[y][x].unit.hp > 0) {
				grid[y][x].showAttackRange();
			}
		}
	}
}
function showHealOptions(unit) {
	for (var y = 0; y < GRID_SIZE; y++) {
		for (var x = 0; x < GRID_SIZE; x++) {
			if (unit.canHeal(x, y) && grid[y][x].unit && grid[y][x].unit.team === unit.team && grid[y][x].unit.hp < grid[y][x].unit.maxHp) {
				grid[y][x].showAttackRange();
			}
		}
	}
}
function getReachableTiles(unit) {
	var reachableTiles = [];
	var maxRange = unit.getMovementRange();
	var visited = {};
	var queue = [{
		x: unit.gridX,
		y: unit.gridY,
		cost: 0
	}];
	visited[unit.gridX + ',' + unit.gridY] = true;
	while (queue.length > 0) {
		var current = queue.shift();
		// Check all 4 directions
		var directions = [{
			x: 0,
			y: 1
		}, {
			x: 0,
			y: -1
		}, {
			x: 1,
			y: 0
		}, {
			x: -1,
			y: 0
		}];
		for (var d = 0; d < directions.length; d++) {
			var dir = directions[d];
			var newX = current.x + dir.x;
			var newY = current.y + dir.y;
			var key = newX + ',' + newY;
			if (newX < 0 || newX >= GRID_SIZE || newY < 0 || newY >= GRID_SIZE) continue;
			if (visited[key]) continue;
			if (grid[newY][newX].unit) continue;
			var moveCost = getMoveCost(unit, newX, newY);
			if (moveCost === -1) continue; // Cannot move to this tile
			var newCost = current.cost + moveCost;
			if (newCost <= maxRange) {
				visited[key] = true;
				queue.push({
					x: newX,
					y: newY,
					cost: newCost
				});
				if (newX !== unit.gridX || newY !== unit.gridY) {
					reachableTiles.push({
						x: newX,
						y: newY,
						cost: newCost
					});
				}
			}
		}
	}
	return reachableTiles;
}
function getMoveCost(unit, x, y) {
	var tile = grid[y][x];
	// Water - only dragon riders can cross
	if (tile.terrainType === 'water' && unit.weaponType !== 'dragonRider') {
		return -1; // Cannot move
	}
	// Tree - riders cannot cross, others get movement cost
	if (tile.terrainType === 'tree') {
		if (unit.weaponType === 'rider') {
			return -1; // Cannot move
		}
		if (unit.weaponType === 'dragonRider') {
			return 1; // Normal cost
		}
		return unit.getMovementRange(); // Ends movement for turn
	}
	// Normal terrain and bridges
	return 1;
}
function showEnemyMovementOptions(unit) {
	var reachableTiles = getReachableTiles(unit);
	for (var i = 0; i < reachableTiles.length; i++) {
		var tile = reachableTiles[i];
		grid[tile.y][tile.x].showHighlight();
	}
}
function moveUnit(unit, targetX, targetY) {
	grid[unit.gridY][unit.gridX].unit = null;
	unit.gridX = targetX;
	unit.gridY = targetY;
	grid[targetY][targetX].unit = unit;
	tween(unit, {
		x: grid[targetY][targetX].x,
		y: grid[targetY][targetX].y
	}, {
		duration: 300
	});
	clearHighlights();
}
function isValidMove(unit, x, y) {
	if (x < 0 || x >= GRID_SIZE || y < 0 || y >= GRID_SIZE) return false;
	if (grid[y][x].unit) return false;
	var distance = Math.abs(unit.gridX - x) + Math.abs(unit.gridY - y);
	if (distance > unit.getMovementRange()) return false;
	// Check terrain restrictions
	var targetTile = grid[y][x];
	if (targetTile.terrainType === 'water') {
		// Only dragon riders can cross water
		if (unit.weaponType !== 'dragonRider') return false;
	}
	return true;
}
function getTileFromPosition(screenX, screenY) {
	var startX = (2048 - GRID_SIZE * TILE_SIZE) / 2;
	var startY = (2732 - GRID_SIZE * TILE_SIZE) / 2;
	var gridX = Math.floor((screenX - startX) / TILE_SIZE);
	var gridY = Math.floor((screenY - startY) / TILE_SIZE);
	if (gridX >= 0 && gridX < GRID_SIZE && gridY >= 0 && gridY < GRID_SIZE) {
		return {
			x: gridX,
			y: gridY
		};
	}
	return null;
}
// Game click handler
game.down = function (x, y, obj) {
	var tilePos = getTileFromPosition(x, y);
	if (!tilePos) return;
	var clickedTile = grid[tilePos.y][tilePos.x];
	if (turnPhase === 'select') {
		// Handle enemy unit selection for viewing movement
		if (clickedTile.unit && clickedTile.unit.team !== currentTurn) {
			if (selectedEnemyUnit === clickedTile.unit) {
				// Clicking same enemy again - hide movement
				selectedEnemyUnit = null;
				clearHighlights();
			} else {
				// Clicking different enemy - show movement
				selectedEnemyUnit = clickedTile.unit;
				clearHighlights();
				showEnemyMovementOptions(selectedEnemyUnit);
			}
			return;
		}
		// Clear enemy selection when clicking elsewhere
		if (selectedEnemyUnit) {
			selectedEnemyUnit = null;
			clearHighlights();
		}
		// Handle player unit selection
		if (clickedTile.unit && clickedTile.unit.team === currentTurn && !clickedTile.unit.hasMoved) {
			selectedUnit = clickedTile.unit;
			originalUnitPosition = {
				x: selectedUnit.gridX,
				y: selectedUnit.gridY
			};
			turnPhase = 'move';
			phaseText.setText('Choose destination');
			showMovementOptions(selectedUnit);
		}
	} else if (turnPhase === 'move') {
		// Cancel move selection by clicking anywhere
		if (!isValidMove(selectedUnit, tilePos.x, tilePos.y)) {
			selectedUnit = null;
			originalUnitPosition = null;
			turnPhase = 'select';
			phaseText.setText('Select Unit');
			clearHighlights();
			return;
		}
		if (isValidMove(selectedUnit, tilePos.x, tilePos.y)) {
			moveUnit(selectedUnit, tilePos.x, tilePos.y);
			LK.setTimeout(function () {
				if (!selectedUnit) return;
				if (selectedUnit.weaponType === 'healer') {
					var hasHealTargets = false;
					for (var ty = 0; ty < GRID_SIZE; ty++) {
						for (var tx = 0; tx < GRID_SIZE; tx++) {
							if (selectedUnit.canHeal(tx, ty) && grid[ty][tx].unit && grid[ty][tx].unit.team === selectedUnit.team && grid[ty][tx].unit.hp < grid[ty][tx].unit.maxHp) {
								hasHealTargets = true;
								break;
							}
						}
						if (hasHealTargets) break;
					}
					if (hasHealTargets) {
						turnPhase = 'chooseAction';
						phaseText.setText('Heal or Ignore');
						showActionButtons();
					} else {
						selectedUnit.endTurn();
						turnPhase = 'select';
						phaseText.setText('Select Unit');
						selectedUnit = null;
						originalUnitPosition = null;
						clearHighlights();
						checkAutoEndTurn();
					}
				} else {
					var hasAttackTargets = false;
					for (var ty = 0; ty < GRID_SIZE; ty++) {
						for (var tx = 0; tx < GRID_SIZE; tx++) {
							if (selectedUnit.canAttack(tx, ty) && grid[ty][tx].unit && grid[ty][tx].unit.team !== selectedUnit.team && grid[ty][tx].unit.hp > 0) {
								hasAttackTargets = true;
								break;
							}
						}
						if (hasAttackTargets) break;
					}
					if (hasAttackTargets) {
						turnPhase = 'chooseAction';
						phaseText.setText('Attack or Ignore');
						showActionButtons();
					} else {
						selectedUnit.endTurn();
						turnPhase = 'select';
						phaseText.setText('Select Unit');
						selectedUnit = null;
						originalUnitPosition = null;
						clearHighlights();
						checkAutoEndTurn();
					}
				}
			}, 350);
		}
	} else if (turnPhase === 'heal') {
		if (clickedTile.unit && clickedTile.unit.team === selectedUnit.team && selectedUnit.canHeal(tilePos.x, tilePos.y)) {
			var target = clickedTile.unit;
			selectedUnit.heal(target);
			selectedUnit.endTurn();
			turnPhase = 'select';
			phaseText.setText('Select Unit');
			selectedUnit = null;
			originalUnitPosition = null;
			clearHighlights();
			checkAutoEndTurn();
		} else {
			// Clicked elsewhere during heal - return to original position
			if (originalUnitPosition && selectedUnit) {
				moveUnit(selectedUnit, originalUnitPosition.x, originalUnitPosition.y);
				LK.setTimeout(function () {
					if (selectedUnit) {
						turnPhase = 'move';
						phaseText.setText('Choose destination');
						showMovementOptions(selectedUnit);
					}
				}, 350);
			}
		}
	} else if (turnPhase === 'attack') {
		if (clickedTile.unit && clickedTile.unit.team !== selectedUnit.team && selectedUnit.canAttack(tilePos.x, tilePos.y)) {
			var target = clickedTile.unit;
			// Add attack shake animation
			if (!selectedUnit) return;
			var originalX = selectedUnit.x;
			tween(selectedUnit, {
				x: originalX + 10
			}, {
				duration: 100,
				onFinish: function onFinish() {
					if (!selectedUnit) return;
					tween(selectedUnit, {
						x: originalX - 10
					}, {
						duration: 100,
						onFinish: function onFinish() {
							if (!selectedUnit) return;
							tween(selectedUnit, {
								x: originalX
							}, {
								duration: 100
							});
						}
					});
				}
			});
			var isDead = target.takeDamage(selectedUnit.attack);
			if (isDead) {
				grid[target.gridY][target.gridX].unit = null;
				tween(target, {
					alpha: 0
				}, {
					duration: 500,
					onFinish: function onFinish() {
						target.destroy();
					}
				});
				if (target.team === 'player') {
					var index = playerUnits.indexOf(target);
					if (index > -1) playerUnits.splice(index, 1);
					updateUnitCounters();
					// Check if player commander was defeated
					if (target.type === 'commander') {
						LK.showGameOver();
						return;
					}
				} else {
					var index = enemyUnits.indexOf(target);
					if (index > -1) enemyUnits.splice(index, 1);
					updateUnitCounters();
					// Check if enemy commander was defeated
					if (target.type === 'commander') {
						LK.showYouWin();
						return;
					}
				}
			}
			selectedUnit.endTurn();
			turnPhase = 'select';
			phaseText.setText('Select Unit');
			selectedUnit = null;
			originalUnitPosition = null;
			clearHighlights();
			checkAutoEndTurn();
		} else {
			// Clicked elsewhere during attack - return to original position
			if (originalUnitPosition && selectedUnit) {
				moveUnit(selectedUnit, originalUnitPosition.x, originalUnitPosition.y);
				LK.setTimeout(function () {
					if (selectedUnit) {
						turnPhase = 'move';
						phaseText.setText('Choose destination');
						showMovementOptions(selectedUnit);
					}
				}, 350);
			}
		}
	}
};
// Enemy AI functions
function getValidMovesForUnit(unit) {
	return getReachableTiles(unit);
}
function updateUnitCounters() {
	var alivePlayerUnits = 0;
	var aliveEnemyUnits = 0;
	for (var i = 0; i < playerUnits.length; i++) {
		if (playerUnits[i].hp > 0) alivePlayerUnits++;
	}
	for (var i = 0; i < enemyUnits.length; i++) {
		if (enemyUnits[i].hp > 0) aliveEnemyUnits++;
	}
	playerCounter.setText(alivePlayerUnits + '/8');
	enemyCounter.setText(aliveEnemyUnits + '/8');
}
function findAttackTargets(unit) {
	var targets = [];
	for (var y = 0; y < GRID_SIZE; y++) {
		for (var x = 0; x < GRID_SIZE; x++) {
			if (unit.canAttack(x, y) && grid[y][x].unit && grid[y][x].unit.team !== unit.team && grid[y][x].unit.hp > 0) {
				targets.push({
					unit: grid[y][x].unit,
					x: x,
					y: y
				});
			}
		}
	}
	return targets;
}
function checkAutoEndTurn() {
	if (currentTurn !== 'player') return;
	var allMoved = true;
	for (var i = 0; i < playerUnits.length; i++) {
		if (!playerUnits[i].hasMoved && playerUnits[i].hp > 0) {
			allMoved = false;
			break;
		}
	}
	if (allMoved) {
		// Auto end turn
		LK.setTimeout(function () {
			for (var i = 0; i < playerUnits.length; i++) {
				playerUnits[i].resetTurn();
			}
			currentTurn = 'enemy';
			turnText.setText('Enemy Turn');
			phaseText.setText('Enemy AI thinking...');
			LK.setTimeout(executeEnemyAI, 1000);
		}, 500);
	}
}
function executeEnemyAI() {
	if (currentTurn !== 'enemy') return;
	// Hide end turn button during enemy turn
	endTurnBtn.alpha = 0;
	endTurnBtn.interactive = false;
	var currentEnemyIndex = 0;
	function processNextEnemy() {
		if (currentEnemyIndex >= enemyUnits.length) {
			// All enemies processed, end turn
			for (var i = 0; i < enemyUnits.length; i++) {
				enemyUnits[i].resetTurn();
			}
			currentTurn = 'player';
			turnText.setText('Player Turn');
			selectedUnit = null;
			selectedEnemyUnit = null;
			turnPhase = 'select';
			phaseText.setText('Select Unit');
			clearHighlights();
			removeActionButtons();
			// Show end turn button again for player turn
			endTurnBtn.alpha = 1;
			endTurnBtn.interactive = true;
			return;
		}
		var enemy = enemyUnits[currentEnemyIndex];
		currentEnemyIndex++;
		if (enemy.hasMoved || enemy.hp <= 0) {
			processNextEnemy();
			return;
		}
		// Check if enemy can attack from current position
		var currentTargets = findAttackTargets(enemy);
		if (currentTargets.length > 0) {
			// Attack the first available target
			var target = currentTargets[0].unit;
			// Add attack shake animation
			var originalX = enemy.x;
			tween(enemy, {
				x: originalX + 10
			}, {
				duration: 100,
				onFinish: function onFinish() {
					tween(enemy, {
						x: originalX - 10
					}, {
						duration: 100,
						onFinish: function onFinish() {
							tween(enemy, {
								x: originalX
							}, {
								duration: 100
							});
						}
					});
				}
			});
			var isDead = target.takeDamage(enemy.attack);
			if (isDead) {
				grid[target.gridY][target.gridX].unit = null;
				tween(target, {
					alpha: 0
				}, {
					duration: 500,
					onFinish: function onFinish() {
						target.destroy();
					}
				});
				if (target.team === 'player') {
					var index = playerUnits.indexOf(target);
					if (index > -1) playerUnits.splice(index, 1);
					updateUnitCounters();
					// Check if player commander was defeated
					if (target.type === 'commander') {
						LK.showGameOver();
						return;
					}
				}
			}
			enemy.endTurn();
			LK.setTimeout(processNextEnemy, 500);
			return;
		}
		// Try to move closer to player units
		var validMoves = getValidMovesForUnit(enemy);
		if (validMoves.length > 0) {
			// Find the move that gets closest to any player unit
			var bestMove = null;
			var bestScore = Infinity;
			for (var m = 0; m < validMoves.length; m++) {
				var move = validMoves[m];
				var minDistanceToPlayer = Infinity;
				for (var p = 0; p < playerUnits.length; p++) {
					if (playerUnits[p].hp <= 0) continue;
					var dist = Math.abs(move.x - playerUnits[p].gridX) + Math.abs(move.y - playerUnits[p].gridY);
					minDistanceToPlayer = Math.min(minDistanceToPlayer, dist);
				}
				if (minDistanceToPlayer < bestScore) {
					bestScore = minDistanceToPlayer;
					bestMove = move;
				}
			}
			if (bestMove) {
				moveUnit(enemy, bestMove.x, bestMove.y);
				LK.setTimeout(function () {
					// Check if can attack after moving
					var targetsAfterMove = findAttackTargets(enemy);
					if (targetsAfterMove.length > 0) {
						var target = targetsAfterMove[0].unit;
						// Add attack shake animation
						var originalX = enemy.x;
						tween(enemy, {
							x: originalX + 10
						}, {
							duration: 100,
							onFinish: function onFinish() {
								tween(enemy, {
									x: originalX - 10
								}, {
									duration: 100,
									onFinish: function onFinish() {
										tween(enemy, {
											x: originalX
										}, {
											duration: 100
										});
									}
								});
							}
						});
						var isDead = target.takeDamage(enemy.attack);
						if (isDead) {
							grid[target.gridY][target.gridX].unit = null;
							tween(target, {
								alpha: 0
							}, {
								duration: 500,
								onFinish: function onFinish() {
									target.destroy();
								}
							});
							if (target.team === 'player') {
								var index = playerUnits.indexOf(target);
								if (index > -1) playerUnits.splice(index, 1);
								updateUnitCounters();
								// Check if player commander was defeated
								if (target.type === 'commander') {
									LK.showGameOver();
									return;
								}
							}
						}
					}
					enemy.endTurn();
					LK.setTimeout(processNextEnemy, 500);
				}, 400);
				return;
			}
		}
		// No valid moves, end this unit's turn
		enemy.endTurn();
		LK.setTimeout(processNextEnemy, 300);
	}
	processNextEnemy();
}
// End turn button
endTurnBtn.interactive = true;
endTurnBtn.down = function () {
	if (currentTurn === 'player') {
		for (var i = 0; i < playerUnits.length; i++) {
			playerUnits[i].resetTurn();
		}
		currentTurn = 'enemy';
		turnText.setText('Enemy Turn');
		phaseText.setText('Enemy AI thinking...');
		LK.setTimeout(executeEnemyAI, 1000);
	} else {
		for (var i = 0; i < enemyUnits.length; i++) {
			enemyUnits[i].resetTurn();
		}
		currentTurn = 'player';
		turnText.setText('Player Turn');
	}
	selectedUnit = null;
	selectedEnemyUnit = null;
	originalUnitPosition = null;
	turnPhase = 'select';
	phaseText.setText('Select Unit');
	clearHighlights();
	removeActionButtons();
};
// Initialize game
initializeGrid();
initializeUnits();
updateUnitCounters();

===================================================================
--- original.js
+++ change.js
@@ -262,20 +262,20 @@
 var playerCounter = new Text2('8/8', {
 	size: 35,
 	fill: 0x5555FF
 });
-playerCounter.anchor.set(0, 0);
+playerCounter.anchor.set(0, 1);
 playerCounter.x = 20;
-playerCounter.y = 20;
-LK.gui.topLeft.addChild(playerCounter);
+playerCounter.y = -120;
+LK.gui.bottomLeft.addChild(playerCounter);
 var enemyCounter = new Text2('8/8', {
 	size: 35,
 	fill: 0xFF5555
 });
-enemyCounter.anchor.set(1, 0);
+enemyCounter.anchor.set(1, 1);
 enemyCounter.x = -20;
-enemyCounter.y = 20;
-LK.gui.topRight.addChild(enemyCounter);
+enemyCounter.y = -120;
+LK.gui.bottomRight.addChild(enemyCounter);
 var endTurnBtn = new Text2('End Turn', {
 	size: 50,
 	fill: 0x00FF00
 });
@@ -443,16 +443,16 @@
 		for (var x = 0; x < GRID_SIZE; x++) {
 			grid[y][x].addTerrain('water');
 		}
 	}
-	// Add bridges: horizontal pattern (river-bridge-bridge-river...bridge-bridge-river)
+	// Add bridges: horizontal pattern (river-bridge-bridge then 9 river tiles then bridge-bridge-river)
 	// Bridge 1: columns 1-2, rows 6-8
 	for (var y = 6; y <= 8; y++) {
 		for (var x = 1; x <= 2; x++) {
 			grid[y][x].addTerrain('bridge');
 		}
 	}
-	// Bridge 2: columns 12-13, rows 6-8  
+	// Bridge 2: columns 12-13, rows 6-8
 	for (var y = 6; y <= 8; y++) {
 		for (var x = 12; x <= 13; x++) {
 			grid[y][x].addTerrain('bridge');
 		}