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

/**** 
* Classes
****/ 
var AttackInfo = Container.expand(function () {
	var self = Container.call(this);
	var background = self.attachAsset('bench_area_bg', {
		anchorX: 0,
		anchorY: 0,
		width: 300,
		height: 150
	});
	background.alpha = 0.8;
	self.attackerText = new Text2('', {
		size: 36,
		fill: 0xFFFFFF
	});
	self.attackerText.anchor.set(0, 0.5);
	self.attackerText.x = 10;
	self.attackerText.y = 25;
	self.addChild(self.attackerText);
	self.damageText = new Text2('', {
		size: 36,
		fill: 0xFF0000
	});
	self.damageText.anchor.set(0, 0.5);
	self.damageText.x = 10;
	self.damageText.y = 100;
	self.addChild(self.damageText);
	self.updateInfo = function (attacker, damage) {
		self.attackerText.setText('Attacker: ' + attacker);
		self.damageText.setText('Damage: ' + damage);
	};
	return self;
});
var BenchSlot = Container.expand(function (index) {
	var self = Container.call(this);
	var slotGraphics = self.attachAsset('bench_slot', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.index = index;
	self.unit = null;
	slotGraphics.alpha = 0.5;
	self.down = function (x, y, obj) {
		if (self.unit && gameState === 'planning') {
			draggedUnit = self.unit;
			// Start dragging from current position, not mouse position
			draggedUnit.x = self.x;
			draggedUnit.y = self.y;
			// Store original position and slot
			draggedUnit.originalX = self.x;
			draggedUnit.originalY = self.y;
			draggedUnit.originalSlot = self;
			// Free the bench slot immediately when dragging starts
			self.unit = null;
		}
	};
	return self;
});
var Bullet = Container.expand(function (damage, target) {
	var self = Container.call(this);
	// Default bullet type
	self.bulletType = 'default';
	self.damage = damage;
	self.target = target;
	self.speed = 8;
	// Create bullet graphics based on type
	self.createGraphics = function () {
		// Clear any existing graphics
		self.removeChildren();
		if (self.bulletType === 'arrow') {
			// Create arrow projectile
			var arrowShaft = self.attachAsset('arrow', {
				anchorX: 0.5,
				anchorY: 0.5
			});
			// Arrow head
			var arrowHead = self.attachAsset('arrow_head', {
				anchorX: 0.5,
				anchorY: 0.5
			});
			arrowHead.x = 15;
			arrowHead.rotation = 0.785; // 45 degrees
			// Arrow fletching
			var fletching1 = self.attachAsset('arrow_feather', {
				anchorX: 0.5,
				anchorY: 0.5
			});
			fletching1.x = -10;
			fletching1.y = -3;
			var fletching2 = self.attachAsset('arrow_feather', {
				anchorX: 0.5,
				anchorY: 0.5
			});
			fletching2.x = -10;
			fletching2.y = 3;
			self.speed = 10; // Arrows are faster
		} else if (self.bulletType === 'magic') {
			// Create magic projectile
			var magicCore = self.attachAsset('magic_core', {
				anchorX: 0.5,
				anchorY: 0.5
			});
			// Magic aura
			var magicAura = self.attachAsset('magic_aura', {
				anchorX: 0.5,
				anchorY: 0.5
			});
			magicAura.alpha = 0.5;
			// Magic sparkles
			var sparkle1 = self.attachAsset('magic_sparkle', {
				anchorX: 0.5,
				anchorY: 0.5
			});
			sparkle1.x = -10;
			sparkle1.y = -10;
			var sparkle2 = self.attachAsset('magic_sparkle', {
				anchorX: 0.5,
				anchorY: 0.5
			});
			sparkle2.x = 10;
			sparkle2.y = 10;
			// Add tween for magic glow effect
			tween(magicAura, {
				scaleX: 1.2,
				scaleY: 1.2,
				alpha: 0.3
			}, {
				duration: 300,
				easing: tween.easeInOut,
				onFinish: function onFinish() {
					tween(magicAura, {
						scaleX: 1.0,
						scaleY: 1.0,
						alpha: 0.5
					}, {
						duration: 300,
						easing: tween.easeInOut,
						onFinish: onFinish
					});
				}
			});
			self.speed = 6; // Magic is slower but more visible
		} else {
			// Default bullet
			var bulletGraphics = self.attachAsset('bullet', {
				anchorX: 0.5,
				anchorY: 0.5
			});
		}
	};
	// Create initial graphics
	self.createGraphics();
	self.update = function () {
		if (!self.target || self.target.health <= 0) {
			self.destroy();
			return;
		}
		var dx = self.target.x - self.x;
		var dy = self.target.y - self.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		if (distance < 10) {
			var killed = self.target.takeDamage(self.damage);
			if (killed) {
				// Don't give gold for killing enemies
				LK.getSound('enemyDeath').play();
				for (var i = enemies.length - 1; i >= 0; i--) {
					if (enemies[i] === self.target) {
						enemies[i].destroy();
						enemies.splice(i, 1);
						break;
					}
				}
			}
			self.destroy();
			return;
		}
		var moveX = dx / distance * self.speed;
		var moveY = dy / distance * self.speed;
		self.x += moveX;
		self.y += moveY;
		// Rotate arrow to face target
		if (self.bulletType === 'arrow') {
			self.rotation = Math.atan2(dy, dx);
		}
	};
	return self;
});
var Enemy = Container.expand(function () {
	var self = Container.call(this);
	// Create pixelart enemy character
	var enemyContainer = new Container();
	self.addChild(enemyContainer);
	// Body (red goblin)
	var body = enemyContainer.attachAsset('enemy', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	body.width = 60;
	body.height = 60;
	body.y = 10;
	body.tint = 0xFF4444; // Red tint to match goblin theme
	// Head (darker red)
	var head = enemyContainer.attachAsset('enemy', {
		anchorX: 0.5,
		anchorY: 0.5,
		width: 40,
		height: 35
	});
	head.y = -30;
	head.tint = 0xcc0000;
	// Eyes (white dots)
	var leftEye = enemyContainer.attachAsset('bullet', {
		anchorX: 0.5,
		anchorY: 0.5,
		width: 8,
		height: 8
	});
	leftEye.x = -10;
	leftEye.y = -30;
	leftEye.tint = 0xFFFFFF;
	var rightEye = enemyContainer.attachAsset('bullet', {
		anchorX: 0.5,
		anchorY: 0.5,
		width: 8,
		height: 8
	});
	rightEye.x = 10;
	rightEye.y = -30;
	rightEye.tint = 0xFFFFFF;
	// Claws
	var leftClaw = enemyContainer.attachAsset('enemy', {
		anchorX: 0.5,
		anchorY: 0.5,
		width: 20,
		height: 15
	});
	leftClaw.x = -25;
	leftClaw.y = 5;
	leftClaw.rotation = 0.5;
	leftClaw.tint = 0x800000;
	var rightClaw = enemyContainer.attachAsset('enemy', {
		anchorX: 0.5,
		anchorY: 0.5,
		width: 20,
		height: 15
	});
	rightClaw.x = 25;
	rightClaw.y = 5;
	rightClaw.rotation = -0.5;
	rightClaw.tint = 0x800000;
	// Initial attributes for the enemy
	self.health = 25;
	self.maxHealth = 25;
	self.damage = 15;
	self.armor = 3;
	self.criticalChance = 0.15;
	self.magicResist = 3;
	self.mana = 40;
	self.speed = 2;
	self.range = 1; // Enemy always melee (adjacent cell)
	self.goldValue = 2;
	self.name = "Enemy";
	self.healthBar = null; // Initialize health bar as null
	self.isAttacking = false; // Flag to track if enemy is currently attacking
	self.baseScale = 1.3; // Base scale multiplier for all enemies (30% larger)
	// Apply base scale
	self.scaleX = self.baseScale;
	self.scaleY = self.baseScale;
	self.showHealthBar = function () {
		if (!self.healthBar) {
			self.healthBar = new HealthBar(60, 8); // Create a health bar instance (smaller than units)
			self.healthBar.x = -30; // Position relative to the enemy's center
			self.healthBar.y = -60; // Position above the enemy
			self.addChild(self.healthBar);
		}
		self.healthBar.visible = true; // Ensure health bar is visible
		self.healthBar.updateHealth(self.health, self.maxHealth);
	};
	self.updateHealthBar = function () {
		if (self.healthBar) {
			self.healthBar.updateHealth(self.health, self.maxHealth);
		}
	};
	self.takeDamage = function (damage) {
		self.health -= damage;
		self.updateHealthBar(); // Update health bar when taking damage
		if (self.health <= 0) {
			self.health = 0;
			return true;
		}
		return false;
	};
	self.update = function () {
		if (!self.gridMovement) {
			self.gridMovement = new GridMovement(self, grid);
		}
		self.gridMovement.update();
		// Castle is now treated as a unit on the grid, no special collision logic needed
		// Find and attack units within range (cell-based)
		var closestUnit = null;
		var closestCellDistance = self.range + 1; // Only units within range (cell count) are valid
		for (var y = 0; y < GRID_ROWS; y++) {
			for (var x = 0; x < GRID_COLS; x++) {
				if (grid[y] && grid[y][x]) {
					var gridSlot = grid[y][x];
					if (gridSlot.unit) {
						// Calculate cell-based Manhattan distance
						var cellDist = Math.abs(self.gridX - x) + Math.abs(self.gridY - y);
						// Check if the enemy is completely inside the adjacent cell before attacking
						if (cellDist <= self.range && cellDist < closestCellDistance && self.gridMovement.isMoving === false) {
							closestCellDistance = cellDist;
							closestUnit = gridSlot.unit;
						}
					}
				}
			}
		}
		// Attack the closest unit if found
		if (closestUnit) {
			if (!self.lastAttack) {
				self.lastAttack = 0;
			}
			if (LK.ticks - self.lastAttack >= 60) {
				self.lastAttack = LK.ticks;
				// Add tween animation for enemy attack
				var originalX = self.x;
				var originalY = self.y;
				// Calculate lunge direction towards target
				var dx = closestUnit.x - self.x;
				var dy = closestUnit.y - self.y;
				var dist = Math.sqrt(dx * dx + dy * dy);
				var offset = Math.min(30, dist * 0.25);
				var lungeX = self.x + (dist > 0 ? dx / dist * offset : 0);
				var lungeY = self.y + (dist > 0 ? dy / dist * offset : 0);
				// Prevent multiple attack tweens at once
				if (!self._isAttackTweening) {
					self._isAttackTweening = true;
					self.isAttacking = true; // Set attacking flag
					// Flash enemy red briefly during attack using LK effects
					LK.effects.flashObject(self, 0xFF4444, 300);
					// Lunge towards target
					tween(self, {
						x: lungeX,
						y: lungeY
					}, {
						duration: 120,
						easing: tween.easeOut,
						onFinish: function onFinish() {
							// Apply damage after lunge
							var killed = closestUnit.takeDamage(self.damage);
							if (killed) {
								self.isAttacking = false; // Clear attacking flag if target dies
								for (var y = 0; y < GRID_ROWS; y++) {
									for (var x = 0; x < GRID_COLS; x++) {
										if (grid[y] && grid[y][x]) {
											var gridSlot = grid[y][x];
											if (gridSlot.unit === closestUnit) {
												gridSlot.unit = null;
												closestUnit.destroy();
												for (var i = bench.length - 1; i >= 0; i--) {
													if (bench[i] === closestUnit) {
														bench.splice(i, 1);
														break;
													}
												}
												break;
											}
										}
									}
								}
							}
							// Return to original position
							tween(self, {
								x: originalX,
								y: originalY
							}, {
								duration: 100,
								easing: tween.easeIn,
								onFinish: function onFinish() {
									self._isAttackTweening = false;
									self.isAttacking = false; // Clear attacking flag after animation
								}
							});
						}
					});
				}
			}
		}
	};
	return self;
});
var RangedEnemy = Enemy.expand(function () {
	var self = Enemy.call(this);
	// Remove default enemy graphics
	self.removeChildren();
	// Create pixelart ranged enemy character
	var enemyContainer = new Container();
	self.addChild(enemyContainer);
	// Body (purple archer)
	var body = enemyContainer.attachAsset('enemy', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	body.width = 55;
	body.height = 70;
	body.y = 10;
	body.tint = 0x8A2BE2; // Purple tint to match archer theme
	// Head with hood
	var head = enemyContainer.attachAsset('enemy', {
		anchorX: 0.5,
		anchorY: 0.5,
		width: 35,
		height: 30
	});
	head.y = -35;
	head.tint = 0x6A1B9A;
	// Eyes (glowing yellow)
	var leftEye = enemyContainer.attachAsset('bullet', {
		anchorX: 0.5,
		anchorY: 0.5,
		width: 6,
		height: 6
	});
	leftEye.x = -8;
	leftEye.y = -35;
	leftEye.tint = 0xFFFF00;
	var rightEye = enemyContainer.attachAsset('bullet', {
		anchorX: 0.5,
		anchorY: 0.5,
		width: 6,
		height: 6
	});
	rightEye.x = 8;
	rightEye.y = -35;
	rightEye.tint = 0xFFFF00;
	// Bow
	var bow = enemyContainer.attachAsset('enemy', {
		anchorX: 0.5,
		anchorY: 0.5,
		width: 45,
		height: 12
	});
	bow.x = -25;
	bow.y = 0;
	bow.rotation = 1.57; // 90 degrees
	bow.tint = 0x4B0082;
	// Bowstring
	var bowstring = enemyContainer.attachAsset('enemy', {
		anchorX: 0.5,
		anchorY: 0.5,
		width: 2,
		height: 40
	});
	bowstring.x = -25;
	bowstring.y = 0;
	bowstring.rotation = 1.57;
	bowstring.tint = 0xDDDDDD; // Light grey string
	// Quiver on back
	var quiver = enemyContainer.attachAsset('enemy', {
		anchorX: 0.5,
		anchorY: 0.5,
		width: 15,
		height: 30
	});
	quiver.x = 20;
	quiver.y = -10;
	quiver.tint = 0x2B0040; // Dark purple
	// Override attributes for ranged enemy
	self.health = 20;
	self.maxHealth = 20;
	self.damage = 12;
	self.armor = 2;
	self.criticalChance = 0.1;
	self.magicResist = 2;
	self.mana = 30;
	self.speed = 1.5; // Slightly slower movement
	self.range = 4; // Long range for shooting
	self.goldValue = 3; // More valuable than melee enemies
	self.name = "Ranged Enemy";
	self.fireRate = 75; // Shoots faster - every 1.25 seconds
	self.lastShot = 0;
	self.baseScale = 1.3; // Base scale multiplier for all enemies (30% larger)
	// Apply base scale
	self.scaleX = self.baseScale;
	self.scaleY = self.baseScale;
	// Override update to include ranged attack behavior
	self.update = function () {
		if (!self.gridMovement) {
			self.gridMovement = new GridMovement(self, grid);
		}
		self.gridMovement.update();
		// Find and attack units within range (cell-based)
		var closestUnit = null;
		var closestCellDistance = self.range + 1; // Only units within range (cell count) are valid
		for (var y = 0; y < GRID_ROWS; y++) {
			for (var x = 0; x < GRID_COLS; x++) {
				if (grid[y] && grid[y][x]) {
					var gridSlot = grid[y][x];
					if (gridSlot.unit) {
						// Calculate cell-based Manhattan distance
						var cellDist = Math.abs(self.gridX - x) + Math.abs(self.gridY - y);
						// Check if the enemy can shoot (doesn't need to be stationary like melee)
						if (cellDist <= self.range && cellDist < closestCellDistance) {
							closestCellDistance = cellDist;
							closestUnit = gridSlot.unit;
						}
					}
				}
			}
		}
		// Attack the closest unit if found
		if (closestUnit) {
			if (!self.lastShot) {
				self.lastShot = 0;
			}
			if (LK.ticks - self.lastShot >= self.fireRate) {
				self.lastShot = LK.ticks;
				// Create projectile
				var projectile = new EnemyProjectile(self.damage, closestUnit);
				projectile.x = self.x;
				projectile.y = self.y;
				enemyProjectiles.push(projectile);
				game.addChild(projectile);
				// Add shooting animation
				if (!self._isShootingTweening) {
					self._isShootingTweening = true;
					// Flash enemy blue briefly during shooting using LK effects
					LK.effects.flashObject(self, 0x4444FF, 200);
					self._isShootingTweening = false;
				}
			}
		}
	};
	return self;
});
var EnemyProjectile = Container.expand(function (damage, target) {
	var self = Container.call(this);
	// Create arrow projectile for enemies
	var arrowContainer = new Container();
	self.addChild(arrowContainer);
	// Arrow shaft
	var arrowShaft = arrowContainer.attachAsset('arrow', {
		anchorX: 0.5,
		anchorY: 0.5,
		width: 25,
		height: 6
	});
	arrowShaft.tint = 0x4B0082; // Dark purple for enemy arrows
	// Arrow head
	var arrowHead = arrowContainer.attachAsset('arrow_head', {
		anchorX: 0.5,
		anchorY: 0.5,
		width: 10,
		height: 10
	});
	arrowHead.x = 12;
	arrowHead.rotation = 0.785; // 45 degrees
	arrowHead.tint = 0xFF0000; // Red tip for enemy
	// Arrow fletching
	var fletching = arrowContainer.attachAsset('arrow_feather', {
		anchorX: 0.5,
		anchorY: 0.5,
		width: 8,
		height: 5
	});
	fletching.x = -8;
	fletching.tint = 0x8B008B; // Dark magenta feathers
	self.damage = damage;
	self.target = target;
	self.speed = 6;
	self.update = function () {
		if (!self.target || self.target.health <= 0) {
			self.destroy();
			return;
		}
		var dx = self.target.x - self.x;
		var dy = self.target.y - self.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		if (distance < 15) {
			// Hit target
			var killed = self.target.takeDamage(self.damage);
			if (killed) {
				// Handle target death - remove from grid if it's a unit
				for (var y = 0; y < GRID_ROWS; y++) {
					for (var x = 0; x < GRID_COLS; x++) {
						if (grid[y] && grid[y][x]) {
							var gridSlot = grid[y][x];
							if (gridSlot.unit === self.target) {
								gridSlot.unit = null;
								self.target.destroy();
								for (var i = bench.length - 1; i >= 0; i--) {
									if (bench[i] === self.target) {
										bench.splice(i, 1);
										break;
									}
								}
								break;
							}
						}
					}
				}
			}
			self.destroy();
			return;
		}
		var moveX = dx / distance * self.speed;
		var moveY = dy / distance * self.speed;
		self.x += moveX;
		self.y += moveY;
		// Rotate arrow to face target
		self.rotation = Math.atan2(dy, dx);
	};
	return self;
});
var GridMovement = Container.expand(function (entity, gridRef) {
	var self = Container.call(this);
	self.entity = entity;
	self.gridRef = gridRef;
	self.currentCell = {
		x: entity.gridX,
		y: entity.gridY
	};
	self.targetCell = {
		x: entity.gridX,
		y: entity.gridY
	};
	self.moveSpeed = 2; // Pixels per frame for continuous movement
	self.isMoving = false; // Track if entity is currently moving
	self.pathToTarget = []; // Store calculated path
	self.pathIndex = 0; // Current position in path
	// Helper method to check if a cell is occupied
	self.isCellOccupied = function (x, y) {
		// Check if out of bounds
		if (x < 0 || x >= GRID_COLS || y < 0 || y >= GRID_ROWS) {
			return true;
		}
		// Check if position is occupied by any entity using position tracking
		if (isPositionOccupied(x, y, self.entity)) {
			return true;
		}
		// Check if cell is reserved by another entity
		var cellKey = x + ',' + y;
		if (cellReservations[cellKey] && cellReservations[cellKey] !== self.entity) {
			return true;
		}
		// Check if occupied by a player unit on grid
		if (self.gridRef[y] && self.gridRef[y][x] && self.gridRef[y][x].unit && self.gridRef[y][x].unit !== self.entity) {
			return true;
		}
		return false;
	};
	// A* pathfinding implementation
	self.findPath = function (startX, startY, goalX, goalY) {
		var openSet = [];
		var closedSet = [];
		var cameFrom = {};
		// Helper to create node
		function createNode(x, y, g, h) {
			return {
				x: x,
				y: y,
				g: g,
				// Cost from start
				h: h,
				// Heuristic cost to goal
				f: g + h // Total cost
			};
		}
		// Manhattan distance heuristic
		function heuristic(x1, y1, x2, y2) {
			return Math.abs(x2 - x1) + Math.abs(y2 - y1);
		}
		// Get neighbors of a cell
		function getNeighbors(x, y) {
			var neighbors = [];
			var directions = [{
				x: 0,
				y: -1
			},
			// Up
			{
				x: 1,
				y: 0
			},
			// Right
			{
				x: 0,
				y: 1
			},
			// Down
			{
				x: -1,
				y: 0
			} // Left
			];
			for (var i = 0; i < directions.length; i++) {
				var newX = x + directions[i].x;
				var newY = y + directions[i].y;
				// Skip if occupied (but allow goal position even if occupied)
				if (newX === goalX && newY === goalY || !self.isCellOccupied(newX, newY)) {
					neighbors.push({
						x: newX,
						y: newY
					});
				}
			}
			return neighbors;
		}
		// Initialize start node
		var startNode = createNode(startX, startY, 0, heuristic(startX, startY, goalX, goalY));
		openSet.push(startNode);
		// Track best g scores
		var gScore = {};
		gScore[startX + ',' + startY] = 0;
		while (openSet.length > 0) {
			// Find node with lowest f score
			var current = openSet[0];
			var currentIndex = 0;
			for (var i = 1; i < openSet.length; i++) {
				if (openSet[i].f < current.f) {
					current = openSet[i];
					currentIndex = i;
				}
			}
			// Check if we reached goal
			if (current.x === goalX && current.y === goalY) {
				// Reconstruct path
				var path = [];
				var key = current.x + ',' + current.y;
				while (key && key !== startX + ',' + startY) {
					var coords = key.split(',');
					path.unshift({
						x: parseInt(coords[0]),
						y: parseInt(coords[1])
					});
					key = cameFrom[key];
				}
				return path;
			}
			// Move current from open to closed
			openSet.splice(currentIndex, 1);
			closedSet.push(current);
			// Check neighbors
			var neighbors = getNeighbors(current.x, current.y);
			for (var i = 0; i < neighbors.length; i++) {
				var neighbor = neighbors[i];
				var neighborKey = neighbor.x + ',' + neighbor.y;
				// Skip if in closed set
				var inClosed = false;
				for (var j = 0; j < closedSet.length; j++) {
					if (closedSet[j].x === neighbor.x && closedSet[j].y === neighbor.y) {
						inClosed = true;
						break;
					}
				}
				if (inClosed) {
					continue;
				}
				// Calculate tentative g score
				var tentativeG = current.g + 1;
				// Check if this path is better
				if (!gScore[neighborKey] || tentativeG < gScore[neighborKey]) {
					// Record best path
					cameFrom[neighborKey] = current.x + ',' + current.y;
					gScore[neighborKey] = tentativeG;
					// Add to open set if not already there
					var inOpen = false;
					for (var j = 0; j < openSet.length; j++) {
						if (openSet[j].x === neighbor.x && openSet[j].y === neighbor.y) {
							inOpen = true;
							openSet[j].g = tentativeG;
							openSet[j].f = tentativeG + openSet[j].h;
							break;
						}
					}
					if (!inOpen) {
						var h = heuristic(neighbor.x, neighbor.y, goalX, goalY);
						openSet.push(createNode(neighbor.x, neighbor.y, tentativeG, h));
					}
				}
			}
		}
		// No path found - try simple alternative
		return self.findAlternativePath(goalX, goalY);
	};
	// Helper method to find alternative paths (fallback for when A* fails)
	self.findAlternativePath = function (targetX, targetY) {
		var currentX = self.currentCell.x;
		var currentY = self.currentCell.y;
		// Calculate primary direction
		var dx = targetX - currentX;
		var dy = targetY - currentY;
		// Try moving in the primary direction first
		var moves = [];
		if (Math.abs(dx) > Math.abs(dy)) {
			// Prioritize horizontal movement
			if (dx > 0 && !self.isCellOccupied(currentX + 1, currentY)) {
				return [{
					x: currentX + 1,
					y: currentY
				}];
			}
			if (dx < 0 && !self.isCellOccupied(currentX - 1, currentY)) {
				return [{
					x: currentX - 1,
					y: currentY
				}];
			}
			// Try vertical as alternative
			if (dy > 0 && !self.isCellOccupied(currentX, currentY + 1)) {
				return [{
					x: currentX,
					y: currentY + 1
				}];
			}
			if (dy < 0 && !self.isCellOccupied(currentX, currentY - 1)) {
				return [{
					x: currentX,
					y: currentY - 1
				}];
			}
		} else {
			// Prioritize vertical movement
			if (dy > 0 && !self.isCellOccupied(currentX, currentY + 1)) {
				return [{
					x: currentX,
					y: currentY + 1
				}];
			}
			if (dy < 0 && !self.isCellOccupied(currentX, currentY - 1)) {
				return [{
					x: currentX,
					y: currentY - 1
				}];
			}
			// Try horizontal as alternative
			if (dx > 0 && !self.isCellOccupied(currentX + 1, currentY)) {
				return [{
					x: currentX + 1,
					y: currentY
				}];
			}
			if (dx < 0 && !self.isCellOccupied(currentX - 1, currentY)) {
				return [{
					x: currentX - 1,
					y: currentY
				}];
			}
		}
		return null;
	};
	self.moveToNextCell = function () {
		// Check if this is a structure unit that shouldn't move
		if (self.entity.isStructure) {
			return false; // Structures don't move
		}
		// Check if this is a player unit or enemy
		var isPlayerUnit = self.entity.name && (self.entity.name === "Soldier" || self.entity.name === "Knight" || self.entity.name === "Wizard" || self.entity.name === "Paladin" || self.entity.name === "Ranger" || self.entity.name === "King");
		var targetGridX = -1;
		var targetGridY = -1;
		var shouldMove = false;
		if (isPlayerUnit) {
			// Player units move towards enemies
			var closestEnemy = null;
			var closestDist = 99999;
			for (var i = 0; i < enemies.length; i++) {
				var enemy = enemies[i];
				if (typeof enemy.gridX === "number" && typeof enemy.gridY === "number") {
					var dx = enemy.gridX - self.currentCell.x;
					var dy = enemy.gridY - self.currentCell.y;
					var dist = Math.abs(dx) + Math.abs(dy);
					if (dist < closestDist) {
						closestDist = dist;
						closestEnemy = enemy;
						targetGridX = enemy.gridX;
						targetGridY = enemy.gridY;
					}
				}
			}
			// Only move if enemy found and not in range
			if (closestEnemy && closestDist > self.entity.range) {
				// Check if unit is currently attacking
				if (self.entity.isAttacking) {
					return false; // Don't move while attacking
				}
				shouldMove = true;
			} else {
				// Already in range or no enemy, don't move
				return false;
			}
		} else {
			// Smarter enemy movement logic
			// First, check if enemy is currently in combat (attacking or being attacked)
			if (self.entity.isAttacking) {
				// Stay in place while attacking
				return false;
			}
			// Find closest player unit (excluding king initially)
			var closestUnit = null;
			var closestDist = 99999;
			var kingUnit = null;
			var kingDist = 99999;
			for (var y = 0; y < GRID_ROWS; y++) {
				for (var x = 0; x < GRID_COLS; x++) {
					if (self.gridRef[y] && self.gridRef[y][x] && self.gridRef[y][x].unit) {
						var unit = self.gridRef[y][x].unit;
						var dx = x - self.currentCell.x;
						var dy = y - self.currentCell.y;
						var dist = Math.abs(dx) + Math.abs(dy);
						if (unit.name === "King") {
							// Track king separately
							if (dist < kingDist) {
								kingDist = dist;
								kingUnit = unit;
							}
						} else {
							// Track other player units
							if (dist < closestDist) {
								closestDist = dist;
								closestUnit = unit;
								targetGridX = x;
								targetGridY = y;
							}
						}
					}
				}
			}
			// Determine target based on smart AI logic
			if (closestUnit) {
				// Found a non-king player unit
				var entityRange = self.entity.range || 1;
				// If enemy is within range, stay and fight
				if (closestDist <= entityRange) {
					// Stay in current position - engage in combat
					return false;
				}
				// Move towards the closest player unit
				shouldMove = true;
			} else if (kingUnit) {
				// No other player units remaining, go for the king
				targetGridX = kingUnit.gridX;
				targetGridY = kingUnit.gridY;
				var entityRange = self.entity.range || 1;
				// If enemy is within range of king, stay and fight
				if (kingDist <= entityRange) {
					// Stay in current position - engage king in combat
					return false;
				}
				// Move towards the king
				shouldMove = true;
			} else {
				// No target found, move down as fallback
				targetGridX = self.currentCell.x;
				targetGridY = self.currentCell.y + 1;
				shouldMove = true;
			}
		}
		if (!shouldMove) {
			return false;
		}
		// Use A* pathfinding to find best path
		if (!self.pathToTarget || self.pathToTarget.length === 0 || self.pathIndex >= self.pathToTarget.length) {
			// Calculate new path
			var path = self.findPath(self.currentCell.x, self.currentCell.y, targetGridX, targetGridY);
			if (path && path.length > 0) {
				self.pathToTarget = path;
				self.pathIndex = 0;
			} else {
				// No path found
				return false;
			}
		}
		// Get next cell from path
		var nextCell = self.pathToTarget[self.pathIndex];
		if (!nextCell) {
			return false;
		}
		var nextX = nextCell.x;
		var nextY = nextCell.y;
		// Check if desired cell is still unoccupied
		if (self.isCellOccupied(nextX, nextY)) {
			// Path is blocked, recalculate
			self.pathToTarget = [];
			self.pathIndex = 0;
			return false;
		}
		// Final check if the cell is valid and unoccupied
		if (!self.isCellOccupied(nextX, nextY) && self.gridRef[nextY] && self.gridRef[nextY][nextX]) {
			var targetGridCell = self.gridRef[nextY][nextX];
			// Double-check that no other entity is trying to move to same position at same time
			if (isPositionOccupied(nextX, nextY, self.entity)) {
				return false;
			}
			// Unregister old position
			unregisterEntityPosition(self.entity, self.currentCell.x, self.currentCell.y);
			// Register new position immediately to prevent conflicts
			registerEntityPosition(self.entity);
			// Release old reservation
			var oldCellKey = self.currentCell.x + ',' + self.currentCell.y;
			if (cellReservations[oldCellKey] === self.entity) {
				delete cellReservations[oldCellKey];
			}
			// Reserve new cell
			var newCellKey = nextX + ',' + nextY;
			cellReservations[newCellKey] = self.entity;
			// Update logical position immediately
			self.currentCell.x = nextX;
			self.currentCell.y = nextY;
			self.entity.gridX = nextX;
			self.entity.gridY = nextY;
			// Set target position for smooth movement
			self.targetCell.x = targetGridCell.x;
			self.targetCell.y = targetGridCell.y;
			self.isMoving = true;
			// Add smooth transition animation when starting movement
			if (!self.entity._isMoveTweening) {
				self.entity._isMoveTweening = true;
				// Get base scale (default to 1 if not set)
				var baseScale = self.entity.baseScale || 1;
				// Slight scale and rotation animation when moving
				tween(self.entity, {
					scaleX: baseScale * 1.1,
					scaleY: baseScale * 0.9,
					rotation: self.entity.rotation + (Math.random() > 0.5 ? 0.05 : -0.05)
				}, {
					duration: 150,
					easing: tween.easeOut,
					onFinish: function onFinish() {
						tween(self.entity, {
							scaleX: baseScale,
							scaleY: baseScale,
							rotation: 0
						}, {
							duration: 150,
							easing: tween.easeIn,
							onFinish: function onFinish() {
								self.entity._isMoveTweening = false;
							}
						});
					}
				});
			}
			return true;
		}
		return false;
	};
	self.update = function () {
		// Periodically check if we need to recalculate path (every 30 ticks)
		if (LK.ticks % 30 === 0 && self.pathToTarget && self.pathToTarget.length > 0) {
			// Check if current path is still valid
			var stillValid = true;
			for (var i = self.pathIndex; i < self.pathToTarget.length && i < self.pathIndex + 3; i++) {
				if (self.pathToTarget[i] && self.isCellOccupied(self.pathToTarget[i].x, self.pathToTarget[i].y)) {
					stillValid = false;
					break;
				}
			}
			if (!stillValid) {
				// Path blocked, clear it to force recalculation
				self.pathToTarget = [];
				self.pathIndex = 0;
			}
		}
		// If we have a target position, move towards it smoothly
		if (self.isMoving) {
			var dx = self.targetCell.x - self.entity.x;
			var dy = self.targetCell.y - self.entity.y;
			var distance = Math.sqrt(dx * dx + dy * dy);
			if (distance > self.moveSpeed) {
				// Continue moving towards target
				var moveX = dx / distance * self.moveSpeed;
				var moveY = dy / distance * self.moveSpeed;
				self.entity.x += moveX;
				self.entity.y += moveY;
			} else {
				// Reached target cell
				self.entity.x = self.targetCell.x;
				self.entity.y = self.targetCell.y;
				self.isMoving = false;
				self.pathIndex++; // Move to next cell in path
				// Wait a tick before trying next move to avoid simultaneous conflicts
				if (LK.ticks % 2 === 0) {
					// Immediately try to move to next cell for continuous movement
					self.moveToNextCell();
				}
			}
		} else {
			// Not moving, try to start moving to next cell
			// Add slight randomization to prevent all entities from moving at exact same time
			if (LK.ticks % (2 + Math.floor(Math.random() * 3)) === 0) {
				self.moveToNextCell();
			}
		}
	};
	return self;
});
var GridSlot = Container.expand(function (lane, gridX, gridY) {
	var self = Container.call(this);
	var slotGraphics = self.attachAsset('grid_slot', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.lane = lane;
	self.gridX = gridX;
	self.gridY = gridY;
	self.unit = null;
	slotGraphics.alpha = 0.3;
	self.down = function (x, y, obj) {
		if (self.unit && !draggedUnit && gameState === 'planning') {
			// Prevent moving king after the first placement
			if (self.unit.name === 'King' && wave > 1) {
				return; // King can only be moved at the beginning of the game
			}
			// Allow dragging any unit during planning phase
			draggedUnit = self.unit;
			draggedUnit.originalX = self.x;
			draggedUnit.originalY = self.y;
			draggedUnit.originalGridSlot = self;
			draggedFromGrid = true;
		}
	};
	self.up = function (x, y, obj) {
		if (draggedUnit && !self.unit) {
			self.placeUnit(draggedUnit);
			draggedUnit = null;
		}
	};
	self.placeUnit = function (unit) {
		if (self.unit) {
			return false;
		}
		// Check if position is already occupied by another entity
		if (isPositionOccupied(self.gridX, self.gridY, unit)) {
			return false;
		}
		// Check unit placement limits (don't apply to king)
		if (unit.name !== "King" && !canPlaceMoreUnits(unit.isStructure)) {
			// Show message about reaching unit limit
			var limitType = unit.isStructure ? 'structures' : 'units';
			var limitMessage = new Text2('You have no more room for ' + limitType + ' in the battlefield, level up to increase it!', {
				size: 36,
				fill: 0xFF4444
			});
			limitMessage.anchor.set(0.5, 0.5);
			limitMessage.x = 1024; // Center of screen
			limitMessage.y = 800; // Middle of screen
			game.addChild(limitMessage);
			// Flash the message and fade it out
			LK.effects.flashObject(limitMessage, 0xFFFFFF, 300);
			tween(limitMessage, {
				alpha: 0,
				y: 700
			}, {
				duration: 5000,
				easing: tween.easeOut,
				onFinish: function onFinish() {
					limitMessage.destroy();
				}
			});
			// Return unit to bench - find first available bench slot
			for (var i = 0; i < benchSlots.length; i++) {
				if (!benchSlots[i].unit) {
					benchSlots[i].unit = unit;
					unit.x = benchSlots[i].x;
					unit.y = benchSlots[i].y;
					unit.gridX = -1;
					unit.gridY = -1;
					unit.lane = -1;
					unit.hideHealthBar();
					unit.hideStarIndicator();
					updateBenchDisplay();
					break;
				}
			}
			return false; // Can't place more units
		}
		self.unit = unit;
		// Unregister old position if unit was previously on grid
		if (unit.gridX >= 0 && unit.gridY >= 0) {
			unregisterEntityPosition(unit, unit.gridX, unit.gridY);
		}
		// Ensure unit is positioned exactly at grid cell center (snap to grid)
		unit.x = self.x;
		unit.y = self.y;
		unit.gridX = self.gridX;
		unit.gridY = self.gridY;
		unit.lane = self.lane;
		// Double-check positioning to prevent floating between cells
		var expectedX = GRID_START_X + self.gridX * GRID_CELL_SIZE + GRID_CELL_SIZE / 2;
		var expectedY = GRID_START_Y + self.gridY * GRID_CELL_SIZE + GRID_CELL_SIZE / 2;
		unit.x = expectedX;
		unit.y = expectedY;
		// Add placement animation
		var targetScale = unit.baseScale || 1.3; // Use base scale or default to 1.3
		if (unit.tier === 2) {
			targetScale = (unit.baseScale || 1.3) * 1.2;
		} else if (unit.tier === 3) {
			targetScale = (unit.baseScale || 1.3) * 1.3;
		}
		unit.scaleX = 0;
		unit.scaleY = 0;
		tween(unit, {
			scaleX: targetScale * 1.2,
			scaleY: targetScale * 1.2
		}, {
			duration: 200,
			easing: tween.easeOut,
			onFinish: function onFinish() {
				tween(unit, {
					scaleX: targetScale,
					scaleY: targetScale
				}, {
					duration: 150,
					easing: tween.easeIn
				});
			}
		});
		// Register new position
		registerEntityPosition(unit);
		unit.showHealthBar(); // Show health bar when placed on grid
		unit.updateHealthBar(); // Update health bar to show current health
		unit.showStarIndicator(); // Show star indicator when placed on grid
		// Don't remove from bench - units stay in both places
		updateBenchDisplay();
		countUnitsOnField(); // Update unit counts
		return true;
	};
	return self;
});
var HealthBar = Container.expand(function (width, height) {
	var self = Container.call(this);
	self.maxWidth = width;
	// Background of the health bar
	self.background = self.attachAsset('healthbar_bg', {
		anchorX: 0,
		anchorY: 0.5,
		width: width,
		height: height
	});
	// Foreground of the health bar
	self.foreground = self.attachAsset('healthbar_fg', {
		anchorX: 0,
		anchorY: 0.5,
		width: width,
		height: height
	});
	self.updateHealth = function (currentHealth, maxHealth) {
		var healthRatio = currentHealth / maxHealth;
		self.foreground.width = self.maxWidth * healthRatio;
		if (healthRatio > 0.6) {
			self.foreground.tint = 0x00ff00; // Green
		} else if (healthRatio > 0.3) {
			self.foreground.tint = 0xffff00; // Yellow
		} else {
			self.foreground.tint = 0xff0000; // Red
		}
	};
	return self;
});
var StarIndicator = Container.expand(function (tier) {
	var self = Container.call(this);
	self.tier = tier || 1;
	self.dots = [];
	self.updateStars = function (newTier) {
		self.tier = newTier;
		// Remove existing dots
		for (var i = 0; i < self.dots.length; i++) {
			self.dots[i].destroy();
		}
		self.dots = [];
		// Create new dots based on tier
		var dotSpacing = 12;
		var totalWidth = (self.tier - 1) * dotSpacing;
		var startX = -totalWidth / 2;
		for (var i = 0; i < self.tier; i++) {
			var dot = self.attachAsset('star_dot', {
				anchorX: 0.5,
				anchorY: 0.5
			});
			dot.x = startX + i * dotSpacing;
			dot.y = 0;
			self.dots.push(dot);
		}
	};
	// Initialize with current tier
	self.updateStars(self.tier);
	return self;
});
var Unit = Container.expand(function (tier) {
	var self = Container.call(this);
	self.tier = tier || 1;
	var assetName = 'unit_tier' + self.tier;
	var unitGraphics = self.attachAsset(assetName, {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.health = 100;
	self.maxHealth = 100;
	self.damage = self.tier;
	self.speed = 1; // Attack speed multiplier
	self.fireRate = 60; // Base fire rate in ticks
	self.lastShot = 0;
	self.gridX = -1;
	self.gridY = -1;
	self.lane = -1;
	self.range = 1; // Default range in cells (adjacent/melee). Override in subclasses for ranged units.
	self.healthBar = null; // Initialize health bar as null
	self.starIndicator = null; // Initialize star indicator as null
	self.isAttacking = false; // Flag to track if unit is currently attacking
	self.baseScale = 1.3; // Base scale multiplier for all units (30% larger)
	// Apply base scale
	self.scaleX = self.baseScale;
	self.scaleY = self.baseScale;
	self.showHealthBar = function () {
		if (!self.healthBar) {
			self.healthBar = new HealthBar(80, 10); // Create a health bar instance
			self.healthBar.x = -40; // Position relative to the unit's center
			self.healthBar.y = -60; // Position above the unit
			self.addChild(self.healthBar);
		}
		self.healthBar.visible = true; // Ensure health bar is visible
		self.healthBar.updateHealth(self.health, self.maxHealth);
	};
	self.showStarIndicator = function () {
		if (!self.starIndicator) {
			self.starIndicator = new StarIndicator(self.tier);
			self.starIndicator.x = 0; // Center relative to unit
			self.starIndicator.y = 55; // Position below the unit
			self.addChild(self.starIndicator);
		}
		self.starIndicator.visible = true;
		self.starIndicator.updateStars(self.tier);
		// Scale unit based on tier - two star units are 30% larger
		self.updateUnitScale();
	};
	self.updateUnitScale = function () {
		// Stop any ongoing scale tweens first
		tween.stop(self, {
			scaleX: true,
			scaleY: true
		});
		if (self.tier === 2) {
			// Two star units are 20% larger on top of base scale
			var targetScale = self.baseScale * 1.2;
			self.scaleX = targetScale;
			self.scaleY = targetScale;
			tween(self, {
				scaleX: targetScale,
				scaleY: targetScale
			}, {
				duration: 300,
				easing: tween.easeOut
			});
		} else if (self.tier === 3) {
			// Three star units are 30% larger on top of base scale
			var targetScale = self.baseScale * 1.3;
			self.scaleX = targetScale;
			self.scaleY = targetScale;
			tween(self, {
				scaleX: targetScale,
				scaleY: targetScale
			}, {
				duration: 300,
				easing: tween.easeOut
			});
		} else {
			// Tier 1 units use base scale
			self.scaleX = self.baseScale;
			self.scaleY = self.baseScale;
			tween(self, {
				scaleX: self.baseScale,
				scaleY: self.baseScale
			}, {
				duration: 300,
				easing: tween.easeOut
			});
		}
	};
	self.hideHealthBar = function () {
		if (self.healthBar) {
			self.healthBar.destroy();
			self.healthBar = null;
		}
	};
	self.hideStarIndicator = function () {
		if (self.starIndicator) {
			self.starIndicator.destroy();
			self.starIndicator = null;
		}
	};
	self.updateHealthBar = function () {
		if (self.healthBar) {
			self.healthBar.updateHealth(self.health, self.maxHealth);
		}
	};
	self.takeDamage = function (damage) {
		self.health -= damage;
		if (self.health < 0) {
			self.health = 0;
		} // Ensure health doesn't go below 0
		self.updateHealthBar(); // Update health bar when taking damage
		if (self.health <= 0) {
			self.hideHealthBar(); // Hide health bar when destroyed
			return true;
		}
		return false;
	};
	self.canShoot = function () {
		// Use speed to modify fire rate - higher speed means faster attacks
		var adjustedFireRate = Math.floor(self.fireRate / self.speed);
		return LK.ticks - self.lastShot >= adjustedFireRate;
	};
	self.shoot = function (target) {
		if (!self.canShoot()) {
			return null;
		}
		self.lastShot = LK.ticks;
		// For melee units (range 1), don't create bullets
		if (self.range <= 1) {
			// Melee attack: do incline movement using tween, then apply damage
			var originalX = self.x;
			var originalY = self.y;
			// Calculate incline offset (move 30% toward target, max 40px)
			var dx = target.x - self.x;
			var dy = target.y - self.y;
			var dist = Math.sqrt(dx * dx + dy * dy);
			var offset = Math.min(40, dist * 0.3);
			var inclineX = self.x + (dist > 0 ? dx / dist * offset : 0);
			var inclineY = self.y + (dist > 0 ? dy / dist * offset : 0);
			// Prevent multiple tweens at once
			if (!self._isMeleeTweening) {
				self._isMeleeTweening = true;
				self.isAttacking = true; // Set attacking flag
				tween(self, {
					x: inclineX,
					y: inclineY
				}, {
					duration: 80,
					easing: tween.easeOut,
					onFinish: function onFinish() {
						// Apply damage after lunge
						var killed = target.takeDamage(self.damage);
						if (killed) {
							self.isAttacking = false; // Clear attacking flag if target dies
							// Don't give gold for killing enemies
							LK.getSound('enemyDeath').play();
							for (var i = enemies.length - 1; i >= 0; i--) {
								if (enemies[i] === target) {
									enemies[i].destroy();
									enemies.splice(i, 1);
									break;
								}
							}
						}
						// Tween back to original position
						tween(self, {
							x: originalX,
							y: originalY
						}, {
							duration: 100,
							easing: tween.easeIn,
							onFinish: function onFinish() {
								self._isMeleeTweening = false;
								self.isAttacking = false; // Clear attacking flag after animation
							}
						});
					}
				});
			}
			return null; // No bullet for melee
		}
		// Ranged attack - create bullet
		var bullet = new Bullet(self.damage, target);
		bullet.x = self.x;
		bullet.y = self.y;
		// Customize bullet appearance based on unit type
		if (self.name === "Ranger") {
			// Archer units shoot arrows
			bullet.bulletType = 'arrow';
			bullet.createGraphics(); // Recreate graphics with correct type
		} else if (self.name === "Wizard") {
			// Wizard units shoot magic
			bullet.bulletType = 'magic';
			bullet.createGraphics(); // Recreate graphics with correct type
		}
		return bullet;
	};
	self.findTarget = function () {
		var closestEnemy = null;
		var closestCellDistance = self.range + 1; // Only enemies within range (cell count) are valid
		for (var i = 0; i < enemies.length; i++) {
			var enemy = enemies[i];
			// Calculate cell-based Manhattan distance
			var cellDist = -1;
			if (typeof self.gridX === "number" && typeof self.gridY === "number" && typeof enemy.gridX === "number" && typeof enemy.gridY === "number") {
				cellDist = Math.abs(self.gridX - enemy.gridX) + Math.abs(self.gridY - enemy.gridY);
			}
			if (cellDist >= 0 && cellDist <= self.range && cellDist < closestCellDistance) {
				closestCellDistance = cellDist;
				closestEnemy = enemy;
			}
		}
		return closestEnemy;
	};
	self.update = function () {
		// Only initialize and update GridMovement if unit is placed on grid and during battle phase
		if (self.gridX >= 0 && self.gridY >= 0 && gameState === 'battle') {
			if (!self.gridMovement) {
				self.gridMovement = new GridMovement(self, grid);
			}
			self.gridMovement.update();
		}
		// Add idle animation when not attacking
		if (!self.isAttacking && self.gridX >= 0 && self.gridY >= 0) {
			// Only start idle animation if not already animating
			if (!self._isIdleAnimating) {
				self._isIdleAnimating = true;
				// Random delay before starting idle animation
				var delay = Math.random() * 2000;
				LK.setTimeout(function () {
					if (!self.isAttacking && self._isIdleAnimating) {
						// Calculate target scale based on tier
						var targetScale = self.baseScale;
						if (self.tier === 2) {
							targetScale = self.baseScale * 1.2;
						} else if (self.tier === 3) {
							targetScale = self.baseScale * 1.3;
						}
						// Gentle bobbing animation that respects tier scale
						tween(self, {
							scaleX: targetScale * 1.05,
							scaleY: targetScale * 0.95
						}, {
							duration: 800,
							easing: tween.easeInOut,
							onFinish: function onFinish() {
								tween(self, {
									scaleX: targetScale,
									scaleY: targetScale
								}, {
									duration: 800,
									easing: tween.easeInOut,
									onFinish: function onFinish() {
										self._isIdleAnimating = false;
									}
								});
							}
						});
					}
				}, delay);
			}
		}
	};
	return self;
});
var Wizard = Unit.expand(function () {
	var self = Unit.call(this, 1);
	// Remove default unit graphics
	self.removeChildren();
	// Create pixelart character container
	var characterContainer = new Container();
	self.addChild(characterContainer);
	// Body (blue mage robe)
	var body = characterContainer.attachAsset('wizard', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	body.width = 65;
	body.height = 85;
	body.y = 10;
	body.tint = 0x191970; // Midnight blue to match mage robe theme
	// Head with wizard hat
	var head = characterContainer.attachAsset('wizard', {
		anchorX: 0.5,
		anchorY: 0.5,
		width: 30,
		height: 30
	});
	head.y = -35;
	head.tint = 0xFFDBB5; // Skin color
	// Wizard hat (triangle)
	var hat = characterContainer.attachAsset('wizard', {
		anchorX: 0.5,
		anchorY: 0.5,
		width: 40,
		height: 35
	});
	hat.y = -55;
	hat.tint = 0x000066;
	// Staff (right side)
	var staff = characterContainer.attachAsset('wizard', {
		anchorX: 0.5,
		anchorY: 0.5,
		width: 10,
		height: 80
	});
	staff.x = 35;
	staff.y = -10;
	staff.tint = 0x8B4513;
	// Staff crystal
	var staffCrystal = characterContainer.attachAsset('wizard', {
		anchorX: 0.5,
		anchorY: 0.5,
		width: 20,
		height: 20
	});
	staffCrystal.x = 35;
	staffCrystal.y = -50;
	staffCrystal.tint = 0x00FFFF; // Cyan crystal
	// Initial attributes for the unit
	self.health = 150;
	self.maxHealth = 150;
	self.damage = 15;
	self.armor = 8;
	self.criticalChance = 0.18;
	self.magicResist = 8;
	self.mana = 70;
	self.speed = 0.7;
	self.range = 3; // Example: medium range (3 cells)
	self.name = "Wizard";
	return self;
});
var Wall = Unit.expand(function () {
	var self = Unit.call(this, 1);
	// Remove default unit graphics
	self.removeChildren();
	// Create pixelart wall structure
	var wallContainer = new Container();
	self.addChild(wallContainer);
	// Wall base (stone blocks)
	var wallBase = wallContainer.attachAsset('wall', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	wallBase.width = 90;
	wallBase.height = 80;
	wallBase.y = 10;
	wallBase.tint = 0x808080; // Grey stone
	// Wall top section
	var wallTop = wallContainer.attachAsset('wall', {
		anchorX: 0.5,
		anchorY: 0.5,
		width: 100,
		height: 30
	});
	wallTop.y = -35;
	wallTop.tint = 0x696969; // Darker grey
	// Stone texture details (left)
	var stoneLeft = wallContainer.attachAsset('wall', {
		anchorX: 0.5,
		anchorY: 0.5,
		width: 25,
		height: 20
	});
	stoneLeft.x = -25;
	stoneLeft.y = 0;
	stoneLeft.tint = 0x606060;
	// Stone texture details (right)
	var stoneRight = wallContainer.attachAsset('wall', {
		anchorX: 0.5,
		anchorY: 0.5,
		width: 25,
		height: 20
	});
	stoneRight.x = 25;
	stoneRight.y = 0;
	stoneRight.tint = 0x606060;
	// Stone texture details (center)
	var stoneCenter = wallContainer.attachAsset('wall', {
		anchorX: 0.5,
		anchorY: 0.5,
		width: 30,
		height: 15
	});
	stoneCenter.x = 0;
	stoneCenter.y = 20;
	stoneCenter.tint = 0x505050;
	// Initial attributes for the wall
	self.health = 300;
	self.maxHealth = 300;
	self.damage = 0; // Walls don't attack
	self.armor = 20; // High defense
	self.criticalChance = 0; // No critical chance
	self.magicResist = 15;
	self.mana = 0; // No mana
	self.speed = 0; // Doesn't attack
	self.range = 0; // No range
	self.name = "Wall";
	self.isStructure = true; // Mark as structure
	// Override update to prevent movement
	self.update = function () {
		// Walls don't move or attack, just exist as obstacles
		// Still need to show health bar during battle
		if (gameState === 'battle' && self.gridX >= 0 && self.gridY >= 0) {
			self.showHealthBar();
			self.updateHealthBar();
			self.showStarIndicator();
		}
	};
	// Override shoot to prevent attacking
	self.shoot = function (target) {
		return null; // Walls can't shoot
	};
	// Override findTarget since walls don't attack
	self.findTarget = function () {
		return null;
	};
	return self;
});
var Soldier = Unit.expand(function () {
	var self = Unit.call(this, 1);
	// Remove default unit graphics
	self.removeChildren();
	// Create pixelart character container
	var characterContainer = new Container();
	self.addChild(characterContainer);
	// Body (green base)
	var body = characterContainer.attachAsset('soldier', {
		anchorX: 0.5,
		anchorY: 0.5,
		width: 60,
		height: 80
	});
	body.y = 10;
	body.tint = 0x32CD32; // Lime green to match theme
	// Head (lighter green circle)
	var head = characterContainer.attachAsset('soldier', {
		anchorX: 0.5,
		anchorY: 0.5,
		width: 40,
		height: 40
	});
	head.y = -30;
	head.tint = 0x66ff66;
	// Arms (small rectangles)
	var leftArm = characterContainer.attachAsset('soldier', {
		anchorX: 0.5,
		anchorY: 0.5,
		width: 15,
		height: 40
	});
	leftArm.x = -30;
	leftArm.y = 0;
	leftArm.rotation = 0.3;
	var rightArm = characterContainer.attachAsset('soldier', {
		anchorX: 0.5,
		anchorY: 0.5,
		width: 15,
		height: 40
	});
	rightArm.x = 30;
	rightArm.y = 0;
	rightArm.rotation = -0.3;
	// Sword (held in right hand)
	var sword = characterContainer.attachAsset('soldier', {
		anchorX: 0.5,
		anchorY: 0.5,
		width: 12,
		height: 50
	});
	sword.x = 35;
	sword.y = -10;
	sword.rotation = -0.2;
	sword.tint = 0xC0C0C0; // Silver color
	// Sword hilt
	var swordHilt = characterContainer.attachAsset('soldier', {
		anchorX: 0.5,
		anchorY: 0.5,
		width: 20,
		height: 8
	});
	swordHilt.x = 35;
	swordHilt.y = 15;
	swordHilt.rotation = -0.2;
	swordHilt.tint = 0x8B4513; // Brown hilt
	// Initial attributes for the unit
	self.health = 120;
	self.maxHealth = 120;
	self.damage = 12;
	self.armor = 6;
	self.criticalChance = 0.15;
	self.magicResist = 6;
	self.mana = 60;
	self.speed = 0.7;
	self.range = 1; // Melee (adjacent cell)
	self.name = "Soldier";
	return self;
});
var Ranger = Unit.expand(function () {
	var self = Unit.call(this, 1);
	// Remove default unit graphics
	self.removeChildren();
	// Create pixelart character container
	var characterContainer = new Container();
	self.addChild(characterContainer);
	// Body (light blue ranger outfit)
	var body = characterContainer.attachAsset('ranger', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	body.width = 60;
	body.height = 80;
	body.y = 10;
	body.tint = 0x87CEEB; // Sky blue to match ranger theme
	// Head with hood
	var head = characterContainer.attachAsset('ranger', {
		anchorX: 0.5,
		anchorY: 0.5,
		width: 30,
		height: 30
	});
	head.y = -35;
	head.tint = 0xFFDBB5; // Skin color
	// Hood
	var hood = characterContainer.attachAsset('ranger', {
		anchorX: 0.5,
		anchorY: 0.5,
		width: 50,
		height: 40
	});
	hood.y = -40;
	hood.tint = 0x9d9dff;
	// Bow (left side)
	var bow = characterContainer.attachAsset('ranger', {
		anchorX: 0.5,
		anchorY: 0.5,
		width: 50,
		height: 15
	});
	bow.x = -30;
	bow.y = 0;
	bow.rotation = 1.57; // 90 degrees
	bow.tint = 0x8B4513;
	// Bowstring
	var bowstring = characterContainer.attachAsset('ranger', {
		anchorX: 0.5,
		anchorY: 0.5,
		width: 2,
		height: 45
	});
	bowstring.x = -30;
	bowstring.y = 0;
	bowstring.rotation = 1.57;
	bowstring.tint = 0xFFFFFF; // White string
	// Arrow on right hand
	var arrow = characterContainer.attachAsset('ranger', {
		anchorX: 0.5,
		anchorY: 0.5,
		width: 4,
		height: 35
	});
	arrow.x = 25;
	arrow.y = -5;
	arrow.rotation = -0.1;
	arrow.tint = 0x654321; // Dark brown arrow
	// Arrow tip
	var arrowTip = characterContainer.attachAsset('ranger', {
		anchorX: 0.5,
		anchorY: 0.5,
		width: 8,
		height: 8
	});
	arrowTip.x = 25;
	arrowTip.y = -22;
	arrowTip.rotation = 0.785; // 45 degrees
	arrowTip.tint = 0x808080; // Grey tip
	// Initial attributes for the unit
	self.health = 170;
	self.maxHealth = 170;
	self.damage = 17;
	self.armor = 10;
	self.criticalChance = 0.22;
	self.magicResist = 10;
	self.mana = 80;
	self.speed = 0.7;
	self.range = 2; // Example: short range (2 cells)
	self.name = "Ranger";
	return self;
});
var Paladin = Unit.expand(function () {
	var self = Unit.call(this, 1);
	// Remove default unit graphics
	self.removeChildren();
	// Create pixelart character container
	var characterContainer = new Container();
	self.addChild(characterContainer);
	// Body (blue armor)
	var body = characterContainer.attachAsset('paladin', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	body.width = 75;
	body.height = 75;
	body.y = 10;
	body.tint = 0x4169E1; // Royal blue to match armor theme
	// Head
	var head = characterContainer.attachAsset('paladin', {
		anchorX: 0.5,
		anchorY: 0.5,
		width: 35,
		height: 35
	});
	head.y = -35;
	head.tint = 0xFFDBB5; // Skin color
	// Helmet
	var helmet = characterContainer.attachAsset('paladin', {
		anchorX: 0.5,
		anchorY: 0.5,
		width: 45,
		height: 25
	});
	helmet.y = -45;
	helmet.tint = 0x4444FF;
	// Sword (right side)
	var sword = characterContainer.attachAsset('paladin', {
		anchorX: 0.5,
		anchorY: 0.5,
		width: 15,
		height: 60
	});
	sword.x = 35;
	sword.y = -5;
	sword.rotation = -0.2;
	sword.tint = 0xC0C0C0;
	// Sword pommel
	var swordPommel = characterContainer.attachAsset('paladin', {
		anchorX: 0.5,
		anchorY: 0.5,
		width: 12,
		height: 12
	});
	swordPommel.x = 35;
	swordPommel.y = 20;
	swordPommel.tint = 0xFFD700; // Gold pommel
	// Initial attributes for the unit
	self.health = 160;
	self.maxHealth = 160;
	self.damage = 16;
	self.armor = 9;
	self.criticalChance = 0.2;
	self.magicResist = 9;
	self.mana = 75;
	self.speed = 0.7;
	self.range = 1; // Example: short range (2 cells)
	self.name = "Paladin";
	return self;
});
var Knight = Unit.expand(function () {
	var self = Unit.call(this, 1);
	// Remove default unit graphics
	self.removeChildren();
	// Create pixelart character container
	var characterContainer = new Container();
	self.addChild(characterContainer);
	// Body (darker green base)
	var body = characterContainer.attachAsset('knight', {
		anchorX: 0.5,
		anchorY: 0.5,
		width: 70,
		height: 70
	});
	body.y = 10;
	body.tint = 0x228B22; // Forest green to match theme
	// Head (round shape)
	var head = characterContainer.attachAsset('knight', {
		anchorX: 0.5,
		anchorY: 0.5,
		width: 35,
		height: 35
	});
	head.y = -35;
	head.tint = 0x4da24d;
	// Shield (left side)
	var shield = characterContainer.attachAsset('knight', {
		anchorX: 0.5,
		anchorY: 0.5,
		width: 30,
		height: 45
	});
	shield.x = -35;
	shield.y = 0;
	shield.tint = 0x666666;
	// Sword (right side)
	var sword = characterContainer.attachAsset('knight', {
		anchorX: 0.5,
		anchorY: 0.5,
		width: 10,
		height: 45
	});
	sword.x = 30;
	sword.y = -5;
	sword.rotation = -0.15;
	sword.tint = 0xC0C0C0; // Silver color
	// Sword guard
	var swordGuard = characterContainer.attachAsset('knight', {
		anchorX: 0.5,
		anchorY: 0.5,
		width: 18,
		height: 6
	});
	swordGuard.x = 30;
	swordGuard.y = 13;
	swordGuard.rotation = -0.15;
	swordGuard.tint = 0x808080; // Dark grey
	// Initial attributes for the unit
	self.health = 110;
	self.maxHealth = 110;
	self.damage = 11;
	self.armor = 5;
	self.criticalChance = 0.12;
	self.magicResist = 5;
	self.mana = 55;
	self.speed = 0.7;
	self.range = 1; // Melee (adjacent cell)
	self.name = "Knight";
	return self;
});
var King = Unit.expand(function () {
	var self = Unit.call(this, 1);
	// Remove default unit graphics
	self.removeChildren();
	// Create pixelart king character
	var kingContainer = new Container();
	self.addChild(kingContainer);
	// King body (royal robe)
	var body = kingContainer.attachAsset('king', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	body.width = 80;
	body.height = 100;
	body.y = 15;
	body.tint = 0x4B0082; // Royal purple
	// King head (flesh tone)
	var head = kingContainer.attachAsset('king', {
		anchorX: 0.5,
		anchorY: 0.5,
		width: 50,
		height: 50
	});
	head.x = 0;
	head.y = -40;
	head.tint = 0xFFDBB5; // Skin color
	// Crown base
	var crownBase = kingContainer.attachAsset('king', {
		anchorX: 0.5,
		anchorY: 0.5,
		width: 60,
		height: 20
	});
	crownBase.x = 0;
	crownBase.y = -65;
	crownBase.tint = 0xFFFF00; // Yellow
	// Crown points (left)
	var crownLeft = kingContainer.attachAsset('king', {
		anchorX: 0.5,
		anchorY: 0.5,
		width: 12,
		height: 25
	});
	crownLeft.x = -20;
	crownLeft.y = -75;
	crownLeft.tint = 0xFFFF00; // Yellow
	// Crown points (center - tallest)
	var crownCenter = kingContainer.attachAsset('king', {
		anchorX: 0.5,
		anchorY: 0.5,
		width: 15,
		height: 35
	});
	crownCenter.x = 0;
	crownCenter.y = -80;
	crownCenter.tint = 0xFFFF00; // Yellow
	// Crown points (right)
	var crownRight = kingContainer.attachAsset('king', {
		anchorX: 0.5,
		anchorY: 0.5,
		width: 12,
		height: 25
	});
	crownRight.x = 20;
	crownRight.y = -75;
	crownRight.tint = 0xFFFF00; // Yellow
	// Crown jewel (center)
	var crownJewel = kingContainer.attachAsset('king', {
		anchorX: 0.5,
		anchorY: 0.5,
		width: 8,
		height: 8
	});
	crownJewel.x = 0;
	crownJewel.y = -80;
	crownJewel.tint = 0xFF0000; // Red jewel
	// Beard
	var beard = kingContainer.attachAsset('king', {
		anchorX: 0.5,
		anchorY: 0.5,
		width: 30,
		height: 20
	});
	beard.x = 0;
	beard.y = -25;
	beard.tint = 0xC0C0C0; // Grey beard
	// Sword (right hand)
	var sword = kingContainer.attachAsset('king', {
		anchorX: 0.5,
		anchorY: 0.5,
		width: 15,
		height: 80
	});
	sword.x = 45;
	sword.y = 0;
	sword.rotation = -0.2;
	sword.tint = 0xC0C0C0; // Silver blade
	// Sword hilt
	var swordHilt = kingContainer.attachAsset('king', {
		anchorX: 0.5,
		anchorY: 0.5,
		width: 25,
		height: 12
	});
	swordHilt.x = 45;
	swordHilt.y = 35;
	swordHilt.rotation = -0.2;
	swordHilt.tint = 0xC0C0C0; // Silver hilt
	// Royal cape/cloak
	var cape = kingContainer.attachAsset('king', {
		anchorX: 0.5,
		anchorY: 0.5,
		width: 70,
		height: 80
	});
	cape.x = -5;
	cape.y = 20;
	cape.tint = 0x8B0000; // Dark red cape
	// Initial attributes for the king (like a very strong unit)
	self.health = 500;
	self.maxHealth = 500;
	self.damage = 100;
	self.armor = 10;
	self.criticalChance = 0.05;
	self.magicResist = 8;
	self.mana = 100;
	self.speed = 0.5; // Slower attack speed
	self.range = 1; // Melee range
	self.name = "King";
	self.fireRate = 120; // Slower fire rate
	// Override takeDamage to handle king-specific game over
	self.takeDamage = function (damage) {
		self.health -= damage;
		if (self.health < 0) {
			self.health = 0;
		}
		self.updateHealthBar();
		if (self.health <= 0) {
			LK.effects.flashScreen(0xFF0000, 500);
			LK.showGameOver();
			return true;
		}
		return false;
	};
	// Override update - King can move if it's the only unit left
	self.update = function () {
		// Check if king is the only player unit left on the battlefield
		var playerUnitsOnGrid = 0;
		for (var y = 0; y < GRID_ROWS; y++) {
			for (var x = 0; x < GRID_COLS; x++) {
				if (grid[y] && grid[y][x] && grid[y][x].unit) {
					playerUnitsOnGrid++;
				}
			}
		}
		// If king is the only unit left, allow movement
		if (playerUnitsOnGrid === 1) {
			// Only initialize and update GridMovement if unit is placed on grid
			if (self.gridX >= 0 && self.gridY >= 0) {
				if (!self.gridMovement) {
					self.gridMovement = new GridMovement(self, grid);
				}
				self.gridMovement.update();
			}
		}
		// King stays in place if other units exist
	};
	// Override showStarIndicator to prevent King from showing stars
	self.showStarIndicator = function () {
		// King doesn't show star indicators
	};
	// Override showHealthBar for king-specific styling
	self.showHealthBar = function () {
		if (!self.healthBar) {
			self.healthBar = new HealthBar(150, 10); // Larger health bar for king
			self.healthBar.x = -75; // Position relative to the king's center
			self.healthBar.y = -110; // Position above the king (higher due to crown)
			self.addChild(self.healthBar);
		}
		self.healthBar.visible = true;
		self.healthBar.updateHealth(self.health, self.maxHealth);
	};
	// Override hideStarIndicator to handle the case where it might be called
	self.hideStarIndicator = function () {
		// King doesn't have star indicators, so nothing to hide
	};
	// Override updateUnitScale to prevent tier-based scaling for King
	self.updateUnitScale = function () {
		// King doesn't scale based on tier, only through levelUpKing function
	};
	return self;
});
var CrossbowTower = Unit.expand(function () {
	var self = Unit.call(this, 1);
	// Remove default unit graphics
	self.removeChildren();
	// Create pixelart crossbow tower structure
	var towerContainer = new Container();
	self.addChild(towerContainer);
	// Tower base (stone foundation)
	var towerBase = towerContainer.attachAsset('crossbow_tower', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	towerBase.width = 80;
	towerBase.height = 60;
	towerBase.y = 30;
	towerBase.tint = 0x696969; // Dark grey stone
	// Tower middle section
	var towerMiddle = towerContainer.attachAsset('crossbow_tower', {
		anchorX: 0.5,
		anchorY: 0.5,
		width: 70,
		height: 50
	});
	towerMiddle.y = -10;
	towerMiddle.tint = 0x808080; // Grey stone
	// Tower top platform
	var towerTop = towerContainer.attachAsset('crossbow_tower', {
		anchorX: 0.5,
		anchorY: 0.5,
		width: 90,
		height: 20
	});
	towerTop.y = -40;
	towerTop.tint = 0x5C4033; // Brown wood platform
	// Crossbow mechanism (horizontal)
	var crossbowBase = towerContainer.attachAsset('crossbow_tower', {
		anchorX: 0.5,
		anchorY: 0.5,
		width: 60,
		height: 15
	});
	crossbowBase.y = -55;
	crossbowBase.rotation = 0;
	crossbowBase.tint = 0x8B4513; // Saddle brown
	// Crossbow arms (vertical)
	var crossbowArms = towerContainer.attachAsset('crossbow_tower', {
		anchorX: 0.5,
		anchorY: 0.5,
		width: 8,
		height: 50
	});
	crossbowArms.y = -55;
	crossbowArms.rotation = 1.57; // 90 degrees
	crossbowArms.tint = 0x654321; // Dark brown
	// Crossbow string
	var crossbowString = towerContainer.attachAsset('crossbow_tower', {
		anchorX: 0.5,
		anchorY: 0.5,
		width: 2,
		height: 48
	});
	crossbowString.y = -55;
	crossbowString.rotation = 1.57;
	crossbowString.tint = 0xDDDDDD; // Light grey string
	// Loaded bolt
	var loadedBolt = towerContainer.attachAsset('crossbow_tower', {
		anchorX: 0.5,
		anchorY: 0.5,
		width: 4,
		height: 30
	});
	loadedBolt.x = 0;
	loadedBolt.y = -55;
	loadedBolt.rotation = 0;
	loadedBolt.tint = 0x4B0082; // Dark purple bolt
	// Initial attributes for the crossbow tower
	self.health = 200;
	self.maxHealth = 200;
	self.damage = 25; // Higher damage than regular ranged units
	self.armor = 12;
	self.criticalChance = 0.25; // High critical chance
	self.magicResist = 10;
	self.mana = 0; // No mana
	self.speed = 0.8; // Slower attack speed
	self.range = 4; // Long range
	self.name = "Crossbow Tower";
	self.isStructure = true; // Mark as structure
	self.fireRate = 90; // Slower fire rate than mobile units
	// Override update to prevent movement but allow shooting
	self.update = function () {
		// Towers don't move but can attack
		if (gameState === 'battle' && self.gridX >= 0 && self.gridY >= 0) {
			self.showHealthBar();
			self.updateHealthBar();
			self.showStarIndicator();
		}
	};
	// Override shoot to create arrow projectiles
	self.shoot = function (target) {
		if (!self.canShoot()) {
			return null;
		}
		self.lastShot = LK.ticks;
		// Create arrow projectile
		var bullet = new Bullet(self.damage, target);
		bullet.x = self.x;
		bullet.y = self.y - 55; // Shoot from crossbow position
		// Crossbow towers shoot arrows
		bullet.bulletType = 'arrow';
		bullet.createGraphics();
		// Add shooting animation - rotate crossbow slightly
		tween(crossbowBase, {
			rotation: -0.1
		}, {
			duration: 100,
			easing: tween.easeOut,
			onFinish: function onFinish() {
				tween(crossbowBase, {
					rotation: 0
				}, {
					duration: 200,
					easing: tween.easeIn
				});
			}
		});
		return bullet;
	};
	return self;
});

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

/**** 
* Game Code
****/ 
var GRID_COLS = 9;
var GRID_ROWS = 9;
var GRID_CELL_SIZE = 227; // 2048 / 9 ≈ 227
var GRID_START_X = (2048 - GRID_COLS * GRID_CELL_SIZE) / 2;
var GRID_START_Y = 100;
var PLAYABLE_HEIGHT = 2400; // Define playable game area
var enemies = [];
var units = [];
var bullets = [];
var enemyProjectiles = [];
var bench = [];
var grid = [];
var benchSlots = [];
var gold = 999;
var wave = 1;
var enemiesSpawned = 0;
var enemiesPerWave = 5;
var waveDelay = 0;
var draggedUnit = null;
var draggedFromGrid = false;
var gameState = 'planning'; // 'planning' or 'battle'
var goldText; // Declare goldText variable
var kingInfoButton; // Declare kingInfoButton variable
var cellReservations = {}; // Track reserved cells during movement
var entityPositions = {}; // Track exact entity positions to prevent overlap
var movementQueue = []; // Queue movements to prevent simultaneous conflicts
var playerLevel = 1; // Player's current level
var maxUnitsOnField = 2; // Starting with 2 units max
var maxStructuresOnField = 2; // Starting with 2 structures max
var structuresOnField = 0; // Track structures placed
var unitsOnField = 0; // Track regular units placed
// Helper function to register entity position
function registerEntityPosition(entity) {
	var posKey = entity.gridX + ',' + entity.gridY;
	entityPositions[posKey] = entity;
}
// Helper function to unregister entity position
function unregisterEntityPosition(entity, oldGridX, oldGridY) {
	var posKey = oldGridX + ',' + oldGridY;
	if (entityPositions[posKey] === entity) {
		delete entityPositions[posKey];
	}
}
// Helper function to check if position is occupied by any entity
function isPositionOccupied(gridX, gridY, excludeEntity) {
	var posKey = gridX + ',' + gridY;
	var occupant = entityPositions[posKey];
	return occupant && occupant !== excludeEntity;
}
// Function to calculate level up cost
function getLevelUpCost(level) {
	return level * 4; // Cost increases by 4 gold per level
}
// Function to count units on field
function countUnitsOnField() {
	structuresOnField = 0;
	unitsOnField = 0;
	for (var y = 0; y < GRID_ROWS; y++) {
		for (var x = 0; x < GRID_COLS; x++) {
			if (grid[y] && grid[y][x] && grid[y][x].unit) {
				var unit = grid[y][x].unit;
				// Skip king - it doesn't count towards any limit
				if (unit.name === "King") {
					continue; // Don't count king
				}
				if (unit.isStructure) {
					structuresOnField++;
				} else {
					unitsOnField++;
				}
			}
		}
	}
	// Update the max units text display
	maxUnitsText.setText('Units: ' + unitsOnField + '/' + maxUnitsOnField + ' | Structures: ' + structuresOnField + '/' + maxStructuresOnField);
}
// Function to check if can place more units
function canPlaceMoreUnits(isStructure) {
	countUnitsOnField();
	if (isStructure) {
		return structuresOnField < maxStructuresOnField;
	} else {
		return unitsOnField < maxUnitsOnField;
	}
}
// Function to level up player
function levelUpPlayer() {
	var cost = getLevelUpCost(playerLevel);
	if (gold >= cost) {
		gold -= cost;
		playerLevel++;
		maxUnitsOnField++; // Increase unit limit by 1
		maxStructuresOnField++; // Increase structure limit by 1
		goldText.setText(gold.toString());
		levelText.setText('King Lvl: ' + playerLevel);
		countUnitsOnField(); // Update counts and display
		// Level up the king
		levelUpKing();
		// Play purchase sound
		LK.getSound('purchase').play();
		// Visual effect
		LK.effects.flashScreen(0xFFD700, 500);
	}
}
// Function to level up king
function levelUpKing() {
	if (kings.length > 0) {
		var king = kings[0];
		// Increase king stats
		king.health = Math.floor(king.health * 1.1);
		king.maxHealth = Math.floor(king.maxHealth * 1.1);
		king.damage = Math.floor(king.damage * 1.1);
		king.armor = Math.floor(king.armor * 1.1);
		king.magicResist = Math.floor(king.magicResist * 1.1);
		// Increase king scale by 10%
		var currentScale = king.scaleX;
		var newScale = currentScale * 1.1;
		tween(king, {
			scaleX: newScale,
			scaleY: newScale
		}, {
			duration: 500,
			easing: tween.easeOut
		});
		// Update health bar
		king.updateHealthBar();
		// Flash effect
		LK.effects.flashObject(king, 0xFFD700, 800);
	}
}
// AttackInfo display removed
// Double-tap detection variables
var lastTapTime = 0;
var lastTapX = 0;
var lastTapY = 0;
var doubleTapDelay = 300; // 300ms window for double tap
var doubleTapDistance = 50; // Max distance between taps
// Create grid slots
for (var y = 0; y < GRID_ROWS; y++) {
	grid[y] = [];
	for (var x = 0; x < GRID_COLS; x++) {
		var gridSlot = game.addChild(new GridSlot(0, x, y)); // Using lane 0 for all slots
		gridSlot.x = GRID_START_X + x * GRID_CELL_SIZE + GRID_CELL_SIZE / 2;
		gridSlot.y = GRID_START_Y + y * GRID_CELL_SIZE + GRID_CELL_SIZE / 2;
		grid[y][x] = gridSlot;
	}
}
// Create king at bottom center of grid
var kings = [];
var king = game.addChild(new King());
// Place king at center column (column 4 for 9x9 grid)
var kingGridX = 4;
var kingGridY = GRID_ROWS - 1;
king.x = GRID_START_X + kingGridX * GRID_CELL_SIZE + GRID_CELL_SIZE / 2;
king.y = GRID_START_Y + kingGridY * GRID_CELL_SIZE + GRID_CELL_SIZE / 2;
king.gridX = kingGridX;
king.gridY = kingGridY;
king.lane = 0;
// King already has baseScale from Unit class, ensure it's applied
king.updateUnitScale();
// Place king on the grid slot
grid[kingGridY][kingGridX].unit = king;
king.showHealthBar(); // Show health bar for king from start
kings.push(king);
// Register king position
registerEntityPosition(king);
// Create info button for king
var kingInfoButton = new Container();
var kingInfoButtonBg = kingInfoButton.attachAsset('shop_button', {
	anchorX: 0.5,
	anchorY: 0.5,
	width: 80,
	height: 40
});
kingInfoButtonBg.tint = 0x4444FF;
var kingInfoButtonText = new Text2('Info', {
	size: 32,
	fill: 0xFFFFFF
});
kingInfoButtonText.anchor.set(0.5, 0.5);
kingInfoButton.addChild(kingInfoButtonText);
kingInfoButton.x = king.x;
kingInfoButton.y = king.y + 100; // Position below king
game.addChild(kingInfoButton);
kingInfoButton.up = function () {
	showUnitInfoModal(king);
};
// Create bench area background
var benchAreaBg = game.addChild(LK.getAsset('bench_area_bg', {
	anchorX: 0.5,
	anchorY: 0.5
}));
benchAreaBg.x = 1024; // Center of screen
benchAreaBg.y = PLAYABLE_HEIGHT - 120; // Move bench up by 40px
benchAreaBg.alpha = 0.7;
// Create bench slots
var benchTotalWidth = 10 * 120 + 9 * 40; // 10 slots of 120px width with 40px spacing
var benchStartX = (2048 - benchTotalWidth) / 2 + 60; // Center horizontally
for (var i = 0; i < 10; i++) {
	var benchSlot = game.addChild(new BenchSlot(i));
	benchSlot.x = benchStartX + i * 160;
	benchSlot.y = PLAYABLE_HEIGHT - 120; // Move bench up by 40px
	benchSlots[i] = benchSlot;
}
// Shop configuration
var shopSlots = [];
var unitPool = [1, 1, 1, 1, 1, 2, 2, 2, 2, 2]; // Pool of available unit tiers
var refreshCost = 2;
// Calculate shop area dimensions
var benchBottomY = PLAYABLE_HEIGHT - 120 + 100; // Bench center + half height
var screenBottomY = 2732; // Full screen height
var shopAreaHeight = screenBottomY - benchBottomY;
var shopCenterY = benchBottomY + shopAreaHeight / 2;
// Create shop area background
var shopAreaBg = game.addChild(LK.getAsset('shop_area_bg', {
	anchorX: 0.5,
	anchorY: 0.5,
	width: 2048,
	height: shopAreaHeight
}));
shopAreaBg.x = 1024; // Center of screen
shopAreaBg.y = shopCenterY; // Center vertically in available space
shopAreaBg.alpha = 0.6;
// Create shop slots
var shopTotalWidth = 5 * 200 + 4 * 40; // 5 slots of 200px width with 40px spacing
var shopStartX = (2048 - shopTotalWidth) / 2 + 60; // Center horizontally
for (var i = 0; i < 5; i++) {
	var shopSlot = game.addChild(new Container());
	shopSlot.x = shopStartX + i * 240;
	shopSlot.y = PLAYABLE_HEIGHT + 150; // Position shop units further down
	shopSlot.index = i;
	shopSlot.unit = null;
	shopSlot.tierText = null;
	shopSlot.nameText = null;
	shopSlots.push(shopSlot);
}
// Create refresh button
var refreshButton = game.addChild(new Container());
var refreshButtonBg = refreshButton.attachAsset('shop_button', {
	anchorX: 0.5,
	anchorY: 0.5,
	width: 200,
	height: 80
});
refreshButtonBg.tint = 0xFF8800;
var refreshText = new Text2('Refresh', {
	size: 40,
	fill: 0xFFFFFF
});
refreshText.anchor.set(0.5, 0.5);
refreshButton.addChild(refreshButtonBg);
refreshButton.addChild(refreshText);
refreshButton.x = 2048 - 200;
refreshButton.y = PLAYABLE_HEIGHT + 150; // Match shop area position
refreshButton.up = function () {
	if (gold >= refreshCost) {
		gold -= refreshCost;
		goldText.setText(gold.toString());
		refreshShop();
		LK.getSound('purchase').play();
	}
};
// Create level up button
var levelUpButton = game.addChild(new Container());
var levelUpButtonBg = levelUpButton.attachAsset('shop_button', {
	anchorX: 0.5,
	anchorY: 0.5,
	width: 200,
	height: 80
});
levelUpButtonBg.tint = 0xFF8800;
var levelUpText = new Text2('Level Up', {
	size: 40,
	fill: 0xFFFFFF
});
levelUpText.anchor.set(0.5, 0.5);
levelUpButton.addChild(levelUpText);
levelUpButton.x = 200;
levelUpButton.y = PLAYABLE_HEIGHT + 150; // Position in shop area
levelUpButton.up = function () {
	levelUpPlayer();
};
// Create level up cost text
var levelUpCostText = new Text2('Cost: ' + getLevelUpCost(playerLevel) + 'g', {
	size: 32,
	fill: 0xFFD700
});
levelUpCostText.anchor.set(0.5, 0);
levelUpCostText.x = 200;
levelUpCostText.y = PLAYABLE_HEIGHT + 200;
game.addChild(levelUpCostText);
// Create refresh cost text
var refreshCostText = new Text2('Cost: ' + refreshCost + 'g', {
	size: 32,
	fill: 0xFFD700
});
refreshCostText.anchor.set(0.5, 0);
refreshCostText.x = 2048 - 200;
refreshCostText.y = PLAYABLE_HEIGHT + 200;
game.addChild(refreshCostText);
// Function to refresh shop with new units
function refreshShop() {
	// Clear existing shop units
	for (var i = 0; i < shopSlots.length; i++) {
		if (shopSlots[i].unit) {
			shopSlots[i].unit.destroy();
			shopSlots[i].unit = null;
		}
		if (shopSlots[i].tierText) {
			shopSlots[i].tierText.destroy();
			shopSlots[i].tierText = null;
		}
		if (shopSlots[i].nameText) {
			shopSlots[i].nameText.destroy();
			shopSlots[i].nameText = null;
		}
		if (shopSlots[i].infoButton) {
			shopSlots[i].infoButton.destroy();
			shopSlots[i].infoButton = null;
		}
	}
	// Fill shop with new random units
	for (var i = 0; i < shopSlots.length; i++) {
		var randomTier = unitPool[Math.floor(Math.random() * unitPool.length)];
		var shopUnit;
		var unitConstructor;
		switch (randomTier) {
			case 1:
				var unitTypes = [Soldier, Knight, Wall];
				unitConstructor = unitTypes[Math.floor(Math.random() * unitTypes.length)];
				shopUnit = new unitConstructor();
				break;
			case 2:
				var unitTypes = [Wizard, Paladin, Ranger, CrossbowTower];
				unitConstructor = unitTypes[Math.floor(Math.random() * unitTypes.length)];
				shopUnit = new unitConstructor();
				break;
		}
		shopUnit.x = shopSlots[i].x;
		shopUnit.y = shopSlots[i].y; // Center the unit in the shop slot
		game.addChild(shopUnit);
		shopSlots[i].unit = shopUnit;
		shopSlots[i].unitConstructor = unitConstructor; // Store the constructor reference
		// Add gentle floating animation for shop units
		var baseY = shopUnit.y;
		tween(shopUnit, {
			y: baseY - 10
		}, {
			duration: 1000 + Math.random() * 500,
			easing: tween.easeInOut,
			onFinish: function onFinish() {
				tween(shopUnit, {
					y: baseY
				}, {
					duration: 1000 + Math.random() * 500,
					easing: tween.easeInOut,
					onFinish: onFinish
				});
			}
		});
		// Add unit name text above the image with more spacing
		var nameText = new Text2(shopUnit.name, {
			size: 36,
			fill: 0xFFFFFF
		});
		nameText.anchor.set(0.5, 1); //{3P} // Anchor to bottom center
		nameText.x = shopSlots[i].x;
		nameText.y = shopSlots[i].y - 100; // Position higher above the unit image
		game.addChild(nameText);
		shopSlots[i].nameText = nameText;
		// Add cost text below the image with more spacing
		var cost = randomTier;
		// Special cost for Wall (1g) and CrossbowTower (2g)
		if (shopUnit.name === "Wall") {
			cost = 1;
		} else if (shopUnit.name === "CrossbowTower") {
			cost = 2;
		}
		var costText = new Text2(cost + 'g', {
			size: 36,
			fill: 0xFFD700
		});
		costText.anchor.set(0.5, 0);
		costText.x = shopSlots[i].x;
		costText.y = shopSlots[i].y + 70; // Position well below the unit image
		game.addChild(costText);
		shopSlots[i].tierText = costText;
		// Add info button below cost
		var infoButton = new Container();
		var infoButtonBg = infoButton.attachAsset('shop_button', {
			anchorX: 0.5,
			anchorY: 0.5,
			width: 80,
			height: 40
		});
		infoButtonBg.tint = 0x4444FF;
		var infoButtonText = new Text2('Info', {
			size: 32,
			fill: 0xFFFFFF
		});
		infoButtonText.anchor.set(0.5, 0.5);
		infoButton.addChild(infoButtonText);
		infoButton.x = shopSlots[i].x;
		infoButton.y = shopSlots[i].y + 130; // Position below cost text with more spacing
		game.addChild(infoButton);
		shopSlots[i].infoButton = infoButton;
		// Store unit reference on info button for click handler
		infoButton.shopUnit = shopUnit;
		infoButton.up = function () {
			showUnitInfoModal(this.shopUnit);
		};
	}
}
// Function to show unit info modal
function showUnitInfoModal(unit) {
	// Create modal overlay
	var modalOverlay = game.addChild(new Container());
	modalOverlay.x = 1024; // Center of screen
	modalOverlay.y = 1366; // Center of screen
	// Create modal background
	var modalBg = modalOverlay.attachAsset('shop_area_bg', {
		anchorX: 0.5,
		anchorY: 0.5,
		width: 600,
		height: 800
	});
	modalBg.alpha = 0.95;
	// Add title
	var titleText = new Text2(unit.name, {
		size: 48,
		fill: 0xFFFFFF
	});
	titleText.anchor.set(0.5, 0.5);
	titleText.y = -350;
	modalOverlay.addChild(titleText);
	// Add attributes
	var attributes = ['Health: ' + unit.maxHealth, 'Damage: ' + unit.damage, 'Armor: ' + unit.armor, 'Magic Resist: ' + unit.magicResist, 'Critical Chance: ' + unit.criticalChance * 100 + '%', 'Mana: ' + unit.mana, 'Attack Speed: ' + unit.speed, 'Range: ' + unit.range];
	for (var i = 0; i < attributes.length; i++) {
		var attrText = new Text2(attributes[i], {
			size: 36,
			fill: 0xFFFFFF
		});
		attrText.anchor.set(0.5, 0.5);
		attrText.y = -250 + i * 60;
		modalOverlay.addChild(attrText);
	}
	// Add close button
	var closeButton = new Container();
	var closeButtonBg = closeButton.attachAsset('shop_button', {
		anchorX: 0.5,
		anchorY: 0.5,
		width: 150,
		height: 60
	});
	closeButtonBg.tint = 0xFF4444;
	var closeButtonText = new Text2('Close', {
		size: 36,
		fill: 0xFFFFFF
	});
	closeButtonText.anchor.set(0.5, 0.5);
	closeButton.addChild(closeButtonText);
	closeButton.y = 330;
	modalOverlay.addChild(closeButton);
	closeButton.up = function () {
		modalOverlay.destroy();
	};
}
// Initialize shop with units
refreshShop();
// Create top UI container background
var topUIBg = game.addChild(LK.getAsset('bench_area_bg', {
	anchorX: 0.5,
	anchorY: 0,
	width: 1800,
	height: 160
}));
topUIBg.x = 1024; // Center of screen
topUIBg.y = 10; // Top of screen with small margin
topUIBg.alpha = 0.7;
topUIBg.tint = 0x3a3a3a; // Darker tint for top section
// Create top row elements (Coin, Level, Max Units)
var goldContainer = new Container();
goldContainer.x = 1024 + 650; // Move further right
goldContainer.y = 50;
game.addChild(goldContainer);
// Create detailed pixelart coin
var coinContainer = new Container();
goldContainer.addChild(coinContainer);
coinContainer.x = -50; // Move coin further left to increase spacing
// Coin base (outer ring)
var coinBase = coinContainer.attachAsset('coin_base', {
	anchorX: 0.5,
	anchorY: 0.5
});
// Coin inner ring
var coinInner = coinContainer.attachAsset('coin_inner', {
	anchorX: 0.5,
	anchorY: 0.5
});
// Coin center
var coinCenter = coinContainer.attachAsset('coin_center', {
	anchorX: 0.5,
	anchorY: 0.5
});
// Coin highlight for shine effect
var coinHighlight = coinContainer.attachAsset('coin_highlight', {
	anchorX: 0.5,
	anchorY: 0.5
});
coinHighlight.x = -6;
coinHighlight.y = -6;
// Add subtle rotation animation to make coin feel alive
tween(coinContainer, {
	rotation: 0.1
}, {
	duration: 2000,
	easing: tween.easeInOut,
	onFinish: function onFinish() {
		tween(coinContainer, {
			rotation: -0.1
		}, {
			duration: 2000,
			easing: tween.easeInOut,
			onFinish: onFinish
		});
	}
});
goldText = new Text2(gold.toString(), {
	size: 50,
	fill: 0xFFD700
});
goldText.anchor.set(0.5, 0.5);
goldText.x = 40; // Move number further right to create more space
goldContainer.addChild(goldText);
var levelText = new Text2('King Lvl: ' + playerLevel, {
	size: 50,
	fill: 0x44FF44
});
levelText.anchor.set(0.5, 0.5);
levelText.x = 1024; // Center
levelText.y = 50;
game.addChild(levelText);
var maxUnitsText = new Text2('Units: 0/' + maxUnitsOnField + ' | Structures: 0/' + maxStructuresOnField, {
	size: 50,
	fill: 0xFFFFFF
});
maxUnitsText.anchor.set(0.5, 0.5);
maxUnitsText.x = 1024 - 500; // Left of center
maxUnitsText.y = 50;
game.addChild(maxUnitsText);
// Create bottom row elements (Planning Phase, Next Wave)
var stateText = new Text2('Planning Phase', {
	size: 40,
	fill: 0x44FF44
});
stateText.anchor.set(0.5, 0.5);
stateText.x = 1024 - 300; // Left of center in bottom row
stateText.y = 120;
game.addChild(stateText);
var waveText = new Text2('Wave: ' + wave, {
	size: 40,
	fill: 0xFFFFFF
});
waveText.anchor.set(0.5, 0.5);
waveText.x = 1024 + 300; // Right of center in bottom row
waveText.y = 120;
game.addChild(waveText);
// Function to update state indicator
function updateStateIndicator() {
	if (gameState === 'planning') {
		stateText.setText('Planning Phase');
		// Remove old text and create new one with correct color
		var parent = stateText.parent;
		var x = stateText.x;
		var y = stateText.y;
		stateText.destroy();
		stateText = new Text2('Planning Phase', {
			size: 40,
			fill: 0x44FF44 // Green for planning
		});
		stateText.anchor.set(0.5, 0.5);
		stateText.x = x;
		stateText.y = y;
		parent.addChild(stateText);
		// Enable ready button during planning
		readyButtonBg.tint = 0x44AA44; // Green tint
		readyButtonText.setText('Ready!');
		// Show king info button during planning
		if (kingInfoButton) {
			kingInfoButton.visible = true;
		}
	} else {
		stateText.setText('Battle Phase');
		// Remove old text and create new one with correct color
		var parent = stateText.parent;
		var x = stateText.x;
		var y = stateText.y;
		stateText.destroy();
		stateText = new Text2('Battle Phase', {
			size: 40,
			fill: 0xFF4444 // Red for battle
		});
		stateText.anchor.set(0.5, 0.5);
		stateText.x = x;
		stateText.y = y;
		parent.addChild(stateText);
		// Grey out ready button during battle
		readyButtonBg.tint = 0x666666; // Grey tint
		readyButtonText.setText('Battle');
		// Hide king info button during battle
		if (kingInfoButton) {
			kingInfoButton.visible = false;
		}
	}
}
var readyButton = new Container();
var readyButtonBg = LK.getAsset('shop_button', {
	anchorX: 0.5,
	anchorY: 0.5,
	width: 200,
	height: 60
});
readyButtonBg.tint = 0x44AA44;
var readyButtonText = new Text2('Ready!', {
	size: 36,
	fill: 0xFFFFFF
});
readyButtonText.anchor.set(0.5, 0.5);
readyButton.addChild(readyButtonBg);
readyButton.addChild(readyButtonText);
game.addChild(readyButton);
readyButton.x = 1024; // Center horizontally
readyButton.y = 120; // Same row as state and wave text
readyButton.up = function () {
	if (gameState === 'planning') {
		// Check for upgrades before starting battle
		checkAndUpgradeUnits();
		gameState = 'battle';
		waveDelay = 0;
		enemiesSpawned = 0; // Reset enemies spawned for new wave
		updateStateIndicator(); // Update UI to show battle phase
	}
	// Do nothing if gameState is 'battle' (button is disabled)
};
// Function to check and perform unit upgrades
function checkAndUpgradeUnits() {
	// Group units by name and type
	var unitGroups = {};
	// Count units in bench
	for (var i = 0; i < bench.length; i++) {
		var unit = bench[i];
		if (unit.gridX === -1 && unit.gridY === -1) {
			// Only count bench units
			var key = unit.name + '_' + unit.tier;
			if (!unitGroups[key]) {
				unitGroups[key] = [];
			}
			unitGroups[key].push({
				unit: unit,
				location: 'bench',
				index: i
			});
		}
	}
	// Count units on grid
	for (var y = 0; y < GRID_ROWS; y++) {
		for (var x = 0; x < GRID_COLS; x++) {
			var gridSlot = grid[y][x];
			if (gridSlot.unit) {
				var unit = gridSlot.unit;
				var key = unit.name + '_' + unit.tier;
				if (!unitGroups[key]) {
					unitGroups[key] = [];
				}
				unitGroups[key].push({
					unit: unit,
					location: 'grid',
					gridX: x,
					gridY: y,
					slot: gridSlot
				});
			}
		}
	}
	// Check for upgrades
	for (var key in unitGroups) {
		var group = unitGroups[key];
		if (group.length >= 3) {
			// Find upgrade priority: bench first, then grid
			var benchUnits = group.filter(function (item) {
				return item.location === 'bench';
			});
			var gridUnits = group.filter(function (item) {
				return item.location === 'grid';
			});
			var unitsToMerge = [];
			var upgradeTarget = null;
			var upgradeLocation = null;
			if (gridUnits.length >= 2 && benchUnits.length >= 1) {
				// Priority: Upgrade units on grid when 2 are on field and 1 in bench
				unitsToMerge = gridUnits.slice(0, 2).concat(benchUnits.slice(0, 1));
				upgradeTarget = unitsToMerge[0];
				upgradeLocation = 'grid';
			} else if (gridUnits.length >= 1 && benchUnits.length >= 2) {
				// Upgrade unit on grid using bench units
				unitsToMerge = [gridUnits[0]].concat(benchUnits.slice(0, 2));
				upgradeTarget = unitsToMerge[0];
				upgradeLocation = 'grid';
			} else if (benchUnits.length >= 3) {
				// Upgrade in bench
				unitsToMerge = benchUnits.slice(0, 3);
				upgradeTarget = unitsToMerge[0];
				upgradeLocation = 'bench';
			}
			if (upgradeTarget && unitsToMerge.length === 3) {
				// Perform upgrade
				var baseUnit = upgradeTarget.unit;
				// Upgrade attributes based on tier
				if (baseUnit.tier === 2) {
					// Three star upgrade - multiply stats by 3
					baseUnit.health = Math.floor(baseUnit.health * 3);
					baseUnit.maxHealth = Math.floor(baseUnit.maxHealth * 3);
					baseUnit.damage = Math.floor(baseUnit.damage * 3);
					baseUnit.armor = Math.floor(baseUnit.armor * 3);
					baseUnit.magicResist = Math.floor(baseUnit.magicResist * 3);
					baseUnit.mana = Math.floor(baseUnit.mana * 3);
				} else {
					// Two star upgrade - multiply by 1.8x
					baseUnit.health = Math.floor(baseUnit.health * 1.8);
					baseUnit.maxHealth = Math.floor(baseUnit.maxHealth * 1.8);
					baseUnit.damage = Math.floor(baseUnit.damage * 1.8);
					baseUnit.armor = Math.floor(baseUnit.armor * 1.8);
					baseUnit.magicResist = Math.floor(baseUnit.magicResist * 1.8);
					baseUnit.mana = Math.floor(baseUnit.mana * 1.8);
				}
				baseUnit.tier = baseUnit.tier + 1;
				// Update health bar to reflect new max health
				if (baseUnit.healthBar) {
					baseUnit.updateHealthBar();
				}
				// Update star indicator to reflect new tier
				if (baseUnit.starIndicator) {
					baseUnit.starIndicator.updateStars(baseUnit.tier);
				}
				// Force immediate scale application by stopping any ongoing scale tweens
				tween.stop(baseUnit, {
					scaleX: true,
					scaleY: true
				});
				// Apply the scale immediately based on tier
				var baseScale = baseUnit.baseScale || 1.3;
				var finalScale = baseScale;
				if (baseUnit.tier === 2) {
					finalScale = baseScale * 1.2;
				} else if (baseUnit.tier === 3) {
					finalScale = baseScale * 1.3;
				}
				// Set scale immediately
				baseUnit.scaleX = finalScale;
				baseUnit.scaleY = finalScale;
				// Update unit scale method to ensure consistency
				baseUnit.updateUnitScale();
				// Visual upgrade effect with bounce animation that respects final scale
				LK.effects.flashObject(baseUnit, 0xFFD700, 800); // Gold flash
				tween(baseUnit, {
					scaleX: finalScale * 1.2,
					scaleY: finalScale * 1.2
				}, {
					duration: 300,
					easing: tween.easeOut,
					onFinish: function onFinish() {
						tween(baseUnit, {
							scaleX: finalScale,
							scaleY: finalScale
						}, {
							duration: 200,
							easing: tween.easeIn
						});
					}
				});
				// Remove the other two units
				for (var i = 1; i < unitsToMerge.length; i++) {
					var unitToRemove = unitsToMerge[i];
					if (unitToRemove.location === 'bench') {
						// Remove from bench
						for (var j = bench.length - 1; j >= 0; j--) {
							if (bench[j] === unitToRemove.unit) {
								bench[j].destroy();
								bench.splice(j, 1);
								break;
							}
						}
					} else if (unitToRemove.location === 'grid') {
						// Remove from grid
						unitToRemove.slot.unit = null;
						unregisterEntityPosition(unitToRemove.unit, unitToRemove.gridX, unitToRemove.gridY);
						unitToRemove.unit.destroy();
					}
				}
				// Update displays
				updateBenchDisplay();
			}
		}
	}
}
// Function to show ready button for next wave
function showReadyButton() {
	if (gameState === 'battle') {
		readyButtonBg.tint = 0x666666; // Grey tint during battle
		readyButtonText.setText('Battle');
	} else {
		readyButtonBg.tint = 0x44AA44; // Green tint for next wave
		readyButtonText.setText('Next Wave');
	}
	readyButton.visible = true;
}
// Hide ready button initially (will show after first wave)
function hideReadyButton() {
	readyButton.visible = false;
}
function updateBenchDisplay() {
	// Clear all bench slot references
	for (var i = 0; i < benchSlots.length; i++) {
		benchSlots[i].unit = null;
	}
	// Only display units in bench that are not on the battlefield
	for (var i = 0; i < bench.length; i++) {
		// Skip units that are already placed on the grid
		if (bench[i].gridX !== -1 && bench[i].gridY !== -1) {
			continue;
		}
		// Find the first empty bench slot
		for (var j = 0; j < benchSlots.length; j++) {
			if (!benchSlots[j].unit) {
				benchSlots[j].unit = bench[i];
				// Center the unit in the bench slot
				bench[i].x = benchSlots[j].x;
				bench[i].y = benchSlots[j].y;
				// Show star indicator for units in bench
				bench[i].showStarIndicator();
				break;
			}
		}
	}
}
function spawnEnemy() {
	var spawnX = Math.floor(Math.random() * GRID_COLS);
	// Increase ranged enemy chance as waves progress
	var rangedChance = Math.min(0.3 + wave * 0.05, 0.7);
	var enemy;
	if (Math.random() < rangedChance) {
		enemy = new RangedEnemy();
	} else {
		enemy = new Enemy();
	}
	// Position enemy at the first row (top) of the grid
	enemy.gridX = spawnX;
	enemy.gridY = 0;
	// Set visual position to match grid position
	var topCell = grid[0][spawnX];
	enemy.x = topCell.x;
	enemy.y = topCell.y;
	enemy.lane = 0; // Single grid, so lane is always 0
	// Scale up enemy by 30%
	enemy.scaleX = 1.3;
	enemy.scaleY = 1.3;
	// Significantly increase enemy scaling per wave
	enemy.health = 20 + Math.floor(wave * 10) + Math.floor(Math.pow(wave, 1.5) * 5);
	enemy.maxHealth = enemy.health;
	enemy.damage = 15 + Math.floor(wave * 5) + Math.floor(Math.pow(wave, 1.3) * 3);
	enemy.goldValue = Math.max(2, Math.floor(wave * 1.5));
	enemy.showHealthBar(); // Show health bar when enemy is spawned
	enemy.updateHealthBar();
	enemies.push(enemy);
	game.addChild(enemy);
	// Add spawn animation
	enemy.alpha = 0;
	enemy.scaleX = 0.65; // 0.5 * 1.3
	enemy.scaleY = 1.95; // 1.5 * 1.3
	tween(enemy, {
		alpha: 1,
		scaleX: 1.3,
		scaleY: 1.3
	}, {
		duration: 300,
		easing: tween.easeOut
	});
	// Register enemy position
	registerEntityPosition(enemy);
}
game.move = function (x, y, obj) {
	if (draggedUnit) {
		draggedUnit.x = x;
		draggedUnit.y = y;
	}
};
game.up = function (x, y, obj) {
	// Check for double-tap on grid units when not dragging
	if (!draggedUnit) {
		var currentTime = Date.now();
		var timeDiff = currentTime - lastTapTime;
		var dx = x - lastTapX;
		var dy = y - lastTapY;
		var distance = Math.sqrt(dx * dx + dy * dy);
		// Check if this is a double-tap (within time window and close to last tap)
		if (timeDiff < doubleTapDelay && distance < doubleTapDistance) {
			// Check if double-tap is on a unit in the grid
			for (var gridY = 0; gridY < GRID_ROWS; gridY++) {
				for (var gridX = 0; gridX < GRID_COLS; gridX++) {
					var slot = grid[gridY][gridX];
					if (slot.unit) {
						var unitDx = x - slot.x;
						var unitDy = y - slot.y;
						var unitDistance = Math.sqrt(unitDx * unitDx + unitDy * unitDy);
						if (unitDistance < GRID_CELL_SIZE / 2) {
							// Double-tapped on this unit - show info modal
							showUnitInfoModal(slot.unit);
							lastTapTime = 0; // Reset to prevent triple-tap
							return;
						}
					}
				}
			}
			// Check if double-tap is on a unit in the bench during planning phase
			if (gameState === 'planning') {
				for (var i = 0; i < benchSlots.length; i++) {
					var benchSlot = benchSlots[i];
					if (benchSlot.unit) {
						var unitDx = x - benchSlot.x;
						var unitDy = y - benchSlot.y;
						var unitDistance = Math.sqrt(unitDx * unitDx + unitDy * unitDy);
						if (unitDistance < 60) {
							// Double-tapped on this bench unit - show info modal
							showUnitInfoModal(benchSlot.unit);
							lastTapTime = 0; // Reset to prevent triple-tap
							return;
						}
					}
				}
			}
			// Check if double-tap is on an enemy
			for (var i = 0; i < enemies.length; i++) {
				var enemy = enemies[i];
				var enemyDx = x - enemy.x;
				var enemyDy = y - enemy.y;
				var enemyDistance = Math.sqrt(enemyDx * enemyDx + enemyDy * enemyDy);
				if (enemyDistance < 60) {
					// Double-tapped on this enemy - show info modal
					showUnitInfoModal(enemy);
					lastTapTime = 0; // Reset to prevent triple-tap
					return;
				}
			}
		}
		// Update last tap info for next potential double-tap
		lastTapTime = currentTime;
		lastTapX = x;
		lastTapY = y;
	}
	if (draggedUnit) {
		var dropped = false;
		// Check if dropped on a valid grid slot
		for (var gridY = 0; gridY < GRID_ROWS; gridY++) {
			for (var gridX = 0; gridX < GRID_COLS; gridX++) {
				var slot = grid[gridY][gridX];
				var dx = x - slot.x;
				var dy = y - slot.y;
				var distance = Math.sqrt(dx * dx + dy * dy);
				if (distance < GRID_CELL_SIZE / 2 && !slot.unit) {
					// Valid empty grid slot - ensure exact positioning
					slot.placeUnit(draggedUnit);
					if (draggedFromGrid && draggedUnit.originalGridSlot) {
						// Unregister from old position before clearing slot
						unregisterEntityPosition(draggedUnit, draggedUnit.originalGridSlot.gridX, draggedUnit.originalGridSlot.gridY);
						draggedUnit.originalGridSlot.unit = null;
					}
					dropped = true;
					break;
				}
			}
			if (dropped) {
				break;
			}
		}
		// Check if dropped on bench slot
		if (!dropped) {
			// Prevent King from being moved to bench
			if (draggedUnit.name !== 'King') {
				for (var i = 0; i < benchSlots.length; i++) {
					var benchSlot = benchSlots[i];
					var dx = x - benchSlot.x;
					var dy = y - benchSlot.y;
					var distance = Math.sqrt(dx * dx + dy * dy);
					if (distance < 60 && !benchSlot.unit) {
						// Valid empty bench slot
						benchSlot.unit = draggedUnit;
						draggedUnit.x = benchSlot.x;
						draggedUnit.y = benchSlot.y;
						// Remove from grid if it was on grid
						if (draggedFromGrid && draggedUnit.originalGridSlot) {
							// Unregister from position tracking
							unregisterEntityPosition(draggedUnit, draggedUnit.originalGridSlot.gridX, draggedUnit.originalGridSlot.gridY);
							draggedUnit.originalGridSlot.unit = null;
						}
						draggedUnit.gridX = -1;
						draggedUnit.gridY = -1;
						draggedUnit.lane = -1;
						draggedUnit.hideHealthBar(); // Hide health bar when moved to bench
						draggedUnit.hideStarIndicator(); // Hide star indicator when moved to bench
						dropped = true;
						updateBenchDisplay();
						break;
					}
				}
			}
		}
		// If not dropped on valid slot, return to original position
		if (!dropped) {
			// Handle King separately - must return to grid
			if (draggedUnit.name === 'King') {
				// King must return to original grid position
				if (draggedFromGrid && draggedUnit.originalGridSlot) {
					draggedUnit.x = draggedUnit.originalX;
					draggedUnit.y = draggedUnit.originalY;
					draggedUnit.originalGridSlot.unit = draggedUnit; // Restore unit to original grid slot
				}
			} else {
				// Always return to bench if not placed in a valid cell
				if (draggedUnit.originalSlot) {
					// Return to original bench slot
					draggedUnit.x = draggedUnit.originalX;
					draggedUnit.y = draggedUnit.originalY;
					draggedUnit.originalSlot.unit = draggedUnit;
				} else if (draggedFromGrid && draggedUnit.originalGridSlot) {
					// Unit was dragged from grid but not placed in valid cell - return to bench
					// Find first available bench slot
					var returnedToBench = false;
					for (var i = 0; i < benchSlots.length; i++) {
						if (!benchSlots[i].unit) {
							benchSlots[i].unit = draggedUnit;
							draggedUnit.x = benchSlots[i].x;
							draggedUnit.y = benchSlots[i].y;
							// Unregister from grid position
							unregisterEntityPosition(draggedUnit, draggedUnit.originalGridSlot.gridX, draggedUnit.originalGridSlot.gridY);
							draggedUnit.originalGridSlot.unit = null;
							draggedUnit.gridX = -1;
							draggedUnit.gridY = -1;
							draggedUnit.lane = -1;
							draggedUnit.hideHealthBar();
							draggedUnit.hideStarIndicator(); // Hide star indicator when moved to bench
							returnedToBench = true;
							updateBenchDisplay();
							break;
						}
					}
					// If no bench slot available, return to original grid position
					if (!returnedToBench) {
						draggedUnit.x = draggedUnit.originalX;
						draggedUnit.y = draggedUnit.originalY;
						draggedUnit.originalGridSlot.unit = draggedUnit; // Restore unit to original grid slot
					}
				} else {
					// Unit doesn't have original position - find first available bench slot
					for (var i = 0; i < benchSlots.length; i++) {
						if (!benchSlots[i].unit) {
							benchSlots[i].unit = draggedUnit;
							draggedUnit.x = benchSlots[i].x;
							draggedUnit.y = benchSlots[i].y;
							draggedUnit.gridX = -1;
							draggedUnit.gridY = -1;
							draggedUnit.lane = -1;
							draggedUnit.hideHealthBar();
							draggedUnit.hideStarIndicator(); // Hide star indicator when moved to bench
							updateBenchDisplay();
							break;
						}
					}
				}
			}
		}
		// Clean up
		draggedUnit.originalX = undefined;
		draggedUnit.originalY = undefined;
		draggedUnit.originalSlot = undefined;
		draggedUnit.originalGridSlot = undefined;
		draggedUnit = null;
		draggedFromGrid = false;
	} else {
		// Check if clicking on a shop unit
		for (var i = 0; i < shopSlots.length; i++) {
			var slot = shopSlots[i];
			if (slot.unit) {
				var dx = x - slot.x;
				var dy = y - slot.y;
				var distance = Math.sqrt(dx * dx + dy * dy);
				if (distance < 80) {
					// Increase click area for better usability
					// Within click range of shop unit
					var unitCost = slot.unit.tier;
					// Special cost for Wall (1g) and CrossbowTower (2g)
					if (slot.unit.name === "Wall") {
						unitCost = 1;
					} else if (slot.unit.name === "CrossbowTower") {
						unitCost = 2;
					}
					if (gold >= unitCost) {
						// Find available bench slot
						var availableBenchSlot = false;
						for (var slotIndex = 0; slotIndex < benchSlots.length; slotIndex++) {
							if (!benchSlots[slotIndex].unit) {
								availableBenchSlot = true;
								break;
							}
						}
						if (availableBenchSlot) {
							gold -= unitCost;
							goldText.setText(gold.toString());
							// Create new unit for bench using the same constructor as the shop unit
							var newUnit = new slot.unitConstructor();
							// All units purchased from shop start at tier 1 (1 star) regardless of unit type
							newUnit.tier = 1;
							// Update star indicator to show tier 1
							if (newUnit.starIndicator) {
								newUnit.starIndicator.updateStars(1);
							}
							// Initialize grid position properties
							newUnit.gridX = -1;
							newUnit.gridY = -1;
							newUnit.lane = -1;
							bench.push(newUnit);
							game.addChild(newUnit);
							updateBenchDisplay();
							// Remove purchased unit from shop
							slot.unit.destroy();
							slot.unit = null;
							if (slot.tierText) {
								slot.tierText.destroy();
								slot.tierText = null;
							}
							if (slot.nameText) {
								slot.nameText.destroy();
								slot.nameText = null;
							}
							if (slot.infoButton) {
								slot.infoButton.destroy();
								slot.infoButton = null;
							}
							LK.getSound('purchase').play();
							// Check for upgrades after purchasing a unit
							checkAndUpgradeUnits();
						} else {
							// No bench space available - could add visual feedback here
						}
					}
					break;
				}
			}
		}
	}
};
game.update = function () {
	// Spawn enemies
	if (gameState === 'battle') {
		// Ensure health bars are visible for all enemies
		for (var i = 0; i < enemies.length; i++) {
			enemies[i].showHealthBar();
		}
		// Ensure health bars are visible for all units on the grid
		for (var y = 0; y < GRID_ROWS; y++) {
			for (var x = 0; x < GRID_COLS; x++) {
				var gridSlot = grid[y][x];
				if (gridSlot.unit) {
					gridSlot.unit.showHealthBar();
				}
			}
		}
		if (waveDelay <= 0) {
			if (enemiesSpawned < enemiesPerWave) {
				if (LK.ticks % 60 === 0) {
					spawnEnemy();
					enemiesSpawned++;
				}
			} else if (enemies.length === 0) {
				// Wave complete - transition to planning phase
				gameState = 'planning';
				wave++;
				enemiesPerWave = Math.min(5 + wave * 2, 30);
				waveText.setText('Wave: ' + wave);
				// Calculate interest: 1 gold per 10 saved, max 5
				var interest = Math.min(Math.floor(gold / 10), 5);
				var waveReward = 5 + interest;
				gold += waveReward;
				goldText.setText(gold.toString());
				// Check for unit upgrades when entering planning phase
				checkAndUpgradeUnits();
				// Show reward message
				var rewardText = new Text2('Wave Complete! +' + waveReward + ' Gold (5 + ' + interest + ' interest)', {
					size: 48,
					fill: 0xFFD700
				});
				rewardText.anchor.set(0.5, 0.5);
				rewardText.x = 1024;
				rewardText.y = 800;
				game.addChild(rewardText);
				// Fade out reward text with longer duration
				tween(rewardText, {
					alpha: 0,
					y: 700
				}, {
					duration: 4000,
					easing: tween.easeOut,
					onFinish: function onFinish() {
						rewardText.destroy();
					}
				});
				// Refresh shop with new units after wave completion
				refreshShop();
				showReadyButton(); // Show button for next wave
				updateStateIndicator(); // Update UI to show planning phase
			}
		} else {
			waveDelay--;
		}
		// Castle health bar is now handled as a regular unit
	}
	// Update enemies
	for (var i = enemies.length - 1; i >= 0; i--) {
		var enemy = enemies[i];
		enemy.update();
		// Castle is now a regular unit on the grid, no special handling needed
		enemy.updateHealthBar();
		enemy.showHealthBar(); // Ensure health bar is shown during battle
	}
	// Update unit counts in case any units were destroyed
	countUnitsOnField();
	// Clean up reservations and position tracking for destroyed entities
	var keysToRemove = [];
	for (var key in cellReservations) {
		var entity = cellReservations[key];
		if (!entity.parent) {
			keysToRemove.push(key);
		}
	}
	for (var i = 0; i < keysToRemove.length; i++) {
		delete cellReservations[keysToRemove[i]];
	}
	// Clean up position tracking for destroyed entities
	var posKeysToRemove = [];
	for (var posKey in entityPositions) {
		var entity = entityPositions[posKey];
		if (!entity.parent) {
			posKeysToRemove.push(posKey);
		}
	}
	for (var i = 0; i < posKeysToRemove.length; i++) {
		delete entityPositions[posKeysToRemove[i]];
	}
	// Update units
	for (var y = 0; y < GRID_ROWS; y++) {
		for (var x = 0; x < GRID_COLS; x++) {
			var gridSlot = grid[y][x];
			if (gridSlot.unit) {
				gridSlot.unit.update();
				if (gameState === 'battle') {
					gridSlot.unit.showHealthBar(); // Ensure health bar is shown during battle
					gridSlot.unit.updateHealthBar();
					gridSlot.unit.showStarIndicator(); // Ensure star indicator is shown during battle
				} else {
					// Hide health bars during planning phase
					if (gridSlot.unit.healthBar) {
						gridSlot.unit.healthBar.visible = false;
					}
					// Show star indicators during planning phase for easy tier identification
					gridSlot.unit.showStarIndicator();
				}
			}
		}
	}
	// Unit shooting (only during battle)
	if (gameState === 'battle') {
		for (var y = 0; y < GRID_ROWS; y++) {
			for (var x = 0; x < GRID_COLS; x++) {
				var gridSlot = grid[y][x];
				if (gridSlot.unit) {
					var target = gridSlot.unit.findTarget();
					if (target) {
						var bullet = gridSlot.unit.shoot(target);
						if (bullet) {
							bullets.push(bullet);
							game.addChild(bullet);
							LK.getSound('shoot').play();
						} else if (gridSlot.unit.range <= 100) {
							// Melee attack sound effect (no bullet created)
							if (gridSlot.unit.canShoot()) {
								LK.getSound('shoot').play();
							}
						}
					}
				}
			}
		}
	}
	// Update bullets
	for (var i = bullets.length - 1; i >= 0; i--) {
		var bullet = bullets[i];
		if (bullet && bullet.update) {
			bullet.update();
		}
		if (!bullet.parent) {
			bullets.splice(i, 1);
		}
	}
	// Update enemy projectiles
	for (var i = enemyProjectiles.length - 1; i >= 0; i--) {
		var projectile = enemyProjectiles[i];
		if (projectile && projectile.update) {
			projectile.update();
		}
		if (!projectile.parent) {
			enemyProjectiles.splice(i, 1);
		}
	}
	// Update level up cost text
	levelUpCostText.setText('Cost: ' + getLevelUpCost(playerLevel) + 'g');
	// Check win condition
	if (wave >= 10 && enemies.length === 0 && enemiesSpawned >= enemiesPerWave) {
		LK.showYouWin();
	}
};

===================================================================
--- original.js
+++ change.js
@@ -2834,15 +2834,15 @@
 topUIBg.alpha = 0.7;
 topUIBg.tint = 0x3a3a3a; // Darker tint for top section
 // Create top row elements (Coin, Level, Max Units)
 var goldContainer = new Container();
-goldContainer.x = 1024 + 500; // Right of center
+goldContainer.x = 1024 + 650; // Move further right
 goldContainer.y = 50;
 game.addChild(goldContainer);
 // Create detailed pixelart coin
 var coinContainer = new Container();
 goldContainer.addChild(coinContainer);
-coinContainer.x = -30; // Position coin to the left of the number
+coinContainer.x = -50; // Move coin further left to increase spacing
 // Coin base (outer ring)
 var coinBase = coinContainer.attachAsset('coin_base', {
 	anchorX: 0.5,
 	anchorY: 0.5
@@ -2884,9 +2884,9 @@
 	size: 50,
 	fill: 0xFFD700
 });
 goldText.anchor.set(0.5, 0.5);
-goldText.x = 20; // Position number to the right of the coin
+goldText.x = 40; // Move number further right to create more space
 goldContainer.addChild(goldText);
 var levelText = new Text2('King Lvl: ' + playerLevel, {
 	size: 50,
 	fill: 0x44FF44