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

/**** 
* Classes
****/ 
/** 
	* Represents an Angel of Light ally that stuns enemies and deals high damage to dark enemies.
	*/ 
var AngelOfLight = Container.expand(function () {
	var self = Container.call(this);
	// Create and attach the angel graphic asset (reusing viking_ally for simplicity)
	// Will need a dedicated asset for the Angel of Light if available.
	var graphics = self.attachAsset('angel_of_light_asset', {
		// Placeholder asset
		anchorX: 0.5,
		anchorY: 0.5
	});
	graphics.tint = 0xFFFF00; // Yellow tint for Angel of Light
	self.attackRange = 600; // Moderate attack range
	self.attackDamage = 5; // Base damage
	self.attackInterval = 480; // Attack every 8 seconds (480 ticks)
	self.attackTimer = 0; // Timer for attacks
	self.stunDuration = 5 * 60; // Stun duration in ticks (5 seconds)
	/** 
	* Update method called each game tick by the LK engine.
	* Handles finding targets and using light ability.
	*/ 
	self.update = function () {
		self.attackTimer++;
		var effectiveAttackInterval = Math.max(60, self.attackInterval * allyAttackSpeedMultiplier); // Apply ally attack speed upgrade
		if (self.attackTimer >= effectiveAttackInterval) {
			self.attackTimer = 0; // Reset timer
			// Find the closest enemy within range
			var closestEnemy = null;
			var closestDistance = self.attackRange;
			for (var i = 0; i < enemies.length; i++) {
				var enemy = enemies[i];
				var dx = enemy.x - self.x;
				var dy = enemy.y - self.y;
				var distance = Math.sqrt(dx * dx + dy * dy);
				if (distance < closestDistance) {
					closestDistance = distance;
					closestEnemy = enemy;
				}
			}
			// If an enemy is found, use light ability
			if (closestEnemy) {
				// Apply stun and damage to the target
				if (closestEnemy.tag !== 'Dragon') {
					// Dragons are immune to stuns (slowdown effect)
					closestEnemy.slowTimer = Math.max(closestEnemy.slowTimer, self.stunDuration); // Apply stun (reusing slowTimer)
					closestEnemy.currentSlowAmount = 0.0; // 100% slowdown (stun)
				}
				var damageToDeal = self.attackDamage;
				if (closestEnemy.tag === 'Black') {
					damageToDeal *= 3; // Triple damage against Black enemies
				}
				closestEnemy.takeDamage(damageToDeal, self); // Deal damage
				// Optional: Add visual/sound effect for light ability here later
				LK.effects.flashObject(closestEnemy, 0xFFFFFF, 300); // Flash white for stun/damage
			}
		}
	};
	return self; // Return self for potential inheritance
});
/** 
* Represents an allied archer that shoots arrows independently.
*/ 
var ArcherAlly = Container.expand(function () {
	var self = Container.call(this);
	// Create and attach the archer graphic asset
	var graphics = self.attachAsset('Archer', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// No rotation needed for 'Archer' asset as it's already upright and flipped
	self.fireTimer = 0; // Timer for shooting
	self.fireInterval = 180; // Shoot every 3 seconds (3 * 60 ticks)
	/** 
	* Update method called each game tick by the LK engine.
	* Handles firing logic.
	*/ 
	self.update = function () {
		self.fireTimer++;
		var effectiveFireInterval = Math.max(60, self.fireInterval * allyAttackSpeedMultiplier); // Apply ally attack speed upgrade
		if (self.fireTimer >= effectiveFireInterval) {
			self.fireTimer = 0; // Reset timer
			// Find the closest enemy to shoot at
			var closestEnemy = null;
			var closestDistance = Infinity;
			for (var i = 0; i < enemies.length; i++) {
				var enemy = enemies[i];
				// Calculate distance to the enemy
				var dx = enemy.x - self.x;
				var dy = enemy.y - self.y;
				var distance = Math.sqrt(dx * dx + dy * dy);
				if (distance < closestDistance) {
					closestDistance = distance;
					closestEnemy = enemy;
				}
			}
			// If an enemy is found, fire an arrow
			if (closestEnemy) {
				// Calculate angle towards the closest enemy
				var angle = Math.atan2(closestEnemy.x - self.x, -(closestEnemy.y - self.y));
				// Create a new arrow instance
				var newArrow = new Arrow(angle);
				// Apply multi-shot to allies if the upgrade is enabled for the player
				if (multiShotEnabled) {
					var angle2 = angle + Math.PI / 12; // Offset by 15 degrees
					var newArrow2 = new Arrow(angle2);
					newArrow2.x = self.x;
					newArrow2.y = self.y;
					newArrow2.lastY = newArrow2.y;
					newArrow2.lastX = newArrow2.x;
					game.addChild(newArrow2);
					arrows.push(newArrow2);
					var angle3 = angle - Math.PI / 12; // Offset by -15 degrees
					var newArrow3 = new Arrow(angle3);
					newArrow3.x = self.x;
					newArrow3.y = self.y;
					newArrow3.lastY = newArrow3.y;
					newArrow3.lastX = newArrow3.x;
					game.addChild(newArrow3);
					arrows.push(newArrow3);
				}
				newArrow.x = self.x;
				newArrow.y = self.y;
				// Ally arrows do not count towards the player's reload counter
				// The Arrow class handles piercing level based on player upgrade, but the ally doesn't benefit from player reload.
				// For simplicity, we'll let the ally benefit from player's piercing upgrade.
				newArrow.lastY = newArrow.y;
				newArrow.lastX = newArrow.x;
				// Add the arrow to the game scene and the tracking array.
				game.addChild(newArrow);
				arrows.push(newArrow); // Add to the same arrows array for collision detection
				// Ally doesn't play the 'shoot' sound
			}
		}
	};
	return self; // Return self for potential inheritance
});
// Sound when an enemy reaches the bastion
// No plugins needed for this version of the game.
/** 
* Represents an Arrow fired by the player.
* @param {number} angle - The angle in radians at which the arrow is fired.
*/ 
var Arrow = Container.expand(function (angle) {
	var self = Container.call(this);
	// Create and attach the arrow graphic asset
	var graphics = self.attachAsset('arrow', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	graphics.rotation = angle + Math.PI / 2; // Align arrow graphic with direction
	self.speed = 30; // Speed of the arrow in pixels per tick
	self.vx = Math.sin(angle) * self.speed; // Horizontal velocity component
	self.vy = -Math.cos(angle) * self.speed; // Vertical velocity component (negative Y is up)
	self.pierceLeft = arrowPierceLevel; // How many more enemies this arrow can pierce
	self.damage = arrowDamage; // Damage dealt by this arrow
	self.isPoison = poisonShotsEnabled; // Flag if this arrow applies poison
	self.targetEnemy = null; // Potential target for aimbot
	self.seekSpeed = 0.1; // How quickly the arrow adjusts its direction to seek
	if (aimbotEnabled) {
		// Find the closest enemy to seek if aimbot is enabled
		var closestEnemy = null;
		var closestDistance = Infinity;
		for (var i = 0; i < enemies.length; i++) {
			var enemy = enemies[i];
			var dx = enemy.x - self.x;
			var dy = enemy.y - self.y;
			var distance = Math.sqrt(dx * dx + dy * dy);
			if (distance < closestDistance) {
				closestDistance = distance;
				closestEnemy = enemy;
			}
		}
		if (closestEnemy) {
			self.targetEnemy = closestEnemy;
		}
	}
	/** 
	* Update method called each game tick by the LK engine.
	* Moves the arrow based on its velocity.
	*/ 
	self.update = function () {
		if (aimbotEnabled && self.targetEnemy && self.targetEnemy.parent) {
			// If aimbot is enabled, a target exists and is still in the game, seek it
			var targetAngle = Math.atan2(self.targetEnemy.x - self.x, -(self.targetEnemy.y - self.y));
			// Smoothly adjust the arrow's angle towards the target angle
			var angleDiff = targetAngle - (self.rotation - Math.PI / 2); // Difference considering graphic rotation
			// Normalize angle difference to be between -PI and PI
			if (angleDiff > Math.PI) {
				angleDiff -= 2 * Math.PI;
			}
			if (angleDiff < -Math.PI) {
				angleDiff += 2 * Math.PI;
			}
			// Interpolate angle
			var newAngle = self.rotation - Math.PI / 2 + angleDiff * self.seekSpeed;
			self.rotation = newAngle + Math.PI / 2;
			self.vx = Math.sin(newAngle) * self.speed;
			self.vy = -Math.cos(newAngle) * self.speed;
		} else if (aimbotEnabled && (!self.targetEnemy || !self.targetEnemy.parent)) {
			// If aimbot is enabled but current target is gone, find a new target
			self.targetEnemy = null; // Clear old target
			var closestEnemy = null;
			var closestDistance = Infinity;
			for (var i = 0; i < enemies.length; i++) {
				var enemy = enemies[i];
				var dx = enemy.x - self.x;
				var dy = enemy.y - self.y;
				var distance = Math.sqrt(dx * dx + dy * dy);
				if (distance < closestDistance) {
					closestDistance = distance;
					closestEnemy = enemy;
				}
			}
			if (closestEnemy) {
				self.targetEnemy = closestEnemy;
			}
		}
		self.x += self.vx;
		self.y += self.vy;
	};
	return self; // Return self for potential inheritance
});
/** 
* Represents a Baby Dragon enemy with rage mode when no other dragons are present.
*/ 
var BabyDragon = Container.expand(function () {
	var self = Container.call(this);
	// Create and attach the baby dragon graphic asset
	var graphics = self.attachAsset('baby_dragon_asset', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// No base tint - only apply pink tint when raging
	self.type = 'baby_dragon';
	self.speed = 3; // Base speed (will be set from spawn)
	self.health = 50; // Base health (will be set from spawn)
	self.maxHealth = 50;
	self.dodgeChance = 0.25; // 25% dodge chance (less than adult dragon)
	self.tag = 'Dragon'; // Dragon-tagged enemy
	self.isRaging = false;
	self.rageSpeedMultiplier = 2.0; // Double speed when raging
	self.baseSpeed = self.speed;
	self.poisonStacks = 0;
	self.poisonTimer = 0;
	self.poisonDamagePerTick = 0.05;
	self.slowTimer = 0;
	self.currentSlowAmount = 1.0;
	/** 
	* Update method called each game tick by the LK engine.
	* Moves the baby dragon and checks for rage mode.
	*/ 
	self.update = function () {
		// Check for rage mode (no other dragons on screen)
		var otherDragonsExist = false;
		for (var i = 0; i < enemies.length; i++) {
			var enemy = enemies[i];
			if (enemy !== self && enemy.tag === 'Dragon') {
				otherDragonsExist = true;
				break;
			}
		}
		// Apply or remove rage mode
		if (!otherDragonsExist && !self.isRaging) {
			// Enter rage mode
			self.isRaging = true;
			self.speed = self.baseSpeed * self.rageSpeedMultiplier;
			// Apply pink tint with tween animation
			tween(graphics, {
				tint: 0xFF69B4
			}, {
				duration: 300
			}); // Pink tint when raging
			LK.effects.flashObject(self, 0xFF69B4, 500); // Flash effect with pink
		} else if (otherDragonsExist && self.isRaging) {
			// Exit rage mode
			self.isRaging = false;
			self.speed = self.baseSpeed;
			// Remove tint with tween animation
			tween(graphics, {
				tint: 0xFFFFFF
			}, {
				duration: 300
			}); // Return to normal color
		}
		// Normal movement (dragons are immune to slowdown)
		self.y += self.speed;
		// Apply poison damage
		if (self.poisonStacks > 0) {
			self.poisonTimer++;
			if (self.poisonTimer >= 30) {
				self.poisonTimer = 0;
				var poisonDmg = self.poisonStacks * self.poisonDamagePerTick * 30;
				self.health -= poisonDmg;
			}
			if (self.health <= 0 && self.parent) {
				LK.setScore(LK.getScore() + 1);
				scoreTxt.setText(LK.getScore());
				self.destroy();
				return;
			}
		}
		// Visual feedback based on health
		var healthRatio = self.maxHealth > 0 ? self.health / self.maxHealth : 0;
		graphics.alpha = 0.4 + healthRatio * 0.6;
	};
	/** 
	* Method called when the baby dragon takes damage.
	*/ 
	self.takeDamage = function (damage, source) {
		// Check for dodge
		if (self.dodgeChance > 0 && Math.random() < self.dodgeChance) {
			return false;
		}
		// Dragons are not immune to arrows/cannonballs
		self.health -= damage;
		// Apply poison if applicable
		if (source && source.isPoison) {
			self.poisonStacks++;
			self.poisonTimer = 0;
		}
		// Dragons are immune to slowdown effects
		return self.health <= 0;
	};
	return self;
});
/** 
* Represents a Bomb projectile thrown by a Bomber ally.
* @param {number} targetX - The target X coordinate.
* @param {number} targetY - The target Y coordinate.
*/ 
var Bomb = Container.expand(function (targetX, targetY) {
	var self = Container.call(this);
	// Create and attach the bomb graphic asset
	var graphics = self.attachAsset('bomb_asset', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.targetX = targetX;
	self.targetY = targetY;
	self.startX = self.x;
	self.startY = self.y;
	self.damage = 15; // Area damage
	self.explosionRadius = 200; // Explosion radius
	self.arcHeight = 300; // Height of bomb arc
	self.flightTime = 60; // 1 second flight time
	self.flightTimer = 0;
	self.hasExploded = false;
	/** 
	* Update method called each game tick by the LK engine.
	* Handles arc movement and explosion.
	*/ 
	self.update = function () {
		if (self.hasExploded) {
			return;
		}
		self.flightTimer++;
		var progress = self.flightTimer / self.flightTime;
		if (progress >= 1) {
			// Bomb has reached target, explode
			self.explode();
			return;
		}
		// Calculate arc position
		var baseX = self.startX + (self.targetX - self.startX) * progress;
		var baseY = self.startY + (self.targetY - self.startY) * progress;
		// Add arc height (parabola)
		var arcOffset = -4 * self.arcHeight * progress * (progress - 1);
		self.x = baseX;
		self.y = baseY - arcOffset;
		// Rotate bomb as it flies
		graphics.rotation += 0.2;
	};
	self.explode = function () {
		if (self.hasExploded) {
			return;
		}
		self.hasExploded = true;
		// Create explosion visual effect
		LK.effects.flashScreen(0xFFAA00, 200); // Orange flash
		// Deal area damage to all enemies within radius
		for (var i = enemies.length - 1; i >= 0; i--) {
			var enemy = enemies[i];
			var dx = enemy.x - self.x;
			var dy = enemy.y - self.y;
			var distance = Math.sqrt(dx * dx + dy * dy);
			if (distance <= self.explosionRadius) {
				// Calculate damage falloff (full damage at center, less at edges)
				var damageFalloff = 1 - distance / self.explosionRadius * 0.5;
				var damageToApply = self.damage * damageFalloff;
				var enemyDefeated = enemy.takeDamage(damageToApply, self);
				if (enemyDefeated) {
					LK.setScore(LK.getScore() + 1);
					scoreTxt.setText(LK.getScore());
					enemy.destroy();
					enemies.splice(i, 1);
				}
				// Apply visual effect to hit enemies
				LK.effects.flashObject(enemy, 0xFFAA00, 300);
			}
		}
		self.destroy();
	};
	return self;
});
/** 
* Represents a Bomber ally that throws bombs for area damage.
*/ 
var Bomber = Container.expand(function () {
	var self = Container.call(this);
	// Create and attach the bomber graphic asset
	var graphics = self.attachAsset('bomber_asset', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.attackRange = Infinity; // Infinite attack range like other allies
	self.attackInterval = 240; // Attack every 4 seconds
	self.attackTimer = 0;
	/** 
	* Update method called each game tick by the LK engine.
	* Handles finding targets and throwing bombs.
	*/ 
	self.update = function () {
		self.attackTimer++;
		var effectiveAttackInterval = Math.max(60, self.attackInterval * allyAttackSpeedMultiplier);
		if (self.attackTimer >= effectiveAttackInterval) {
			self.attackTimer = 0;
			// Find a suitable target (not Dragon-tagged)
			var bestTarget = null;
			var bestScore = -1;
			for (var i = 0; i < enemies.length; i++) {
				var enemy = enemies[i];
				// Skip Dragon-tagged enemies
				if (enemy.tag === 'Dragon') {
					continue;
				}
				var dx = enemy.x - self.x;
				var dy = enemy.y - self.y;
				var distance = Math.sqrt(dx * dx + dy * dy);
				if (distance <= self.attackRange) {
					// Prioritize groups of enemies (check nearby enemy count)
					var nearbyCount = 0;
					for (var j = 0; j < enemies.length; j++) {
						if (i !== j) {
							var ex = enemies[j].x - enemy.x;
							var ey = enemies[j].y - enemy.y;
							if (Math.sqrt(ex * ex + ey * ey) <= 200) {
								nearbyCount++;
							}
						}
					}
					var score = nearbyCount * 10 + (self.attackRange - distance) / 100;
					if (score > bestScore) {
						bestScore = score;
						bestTarget = enemy;
					}
				}
			}
			if (bestTarget) {
				// Create and throw bomb
				var bomb = new Bomb(bestTarget.x, bestTarget.y);
				bomb.startX = self.x;
				bomb.startY = self.y;
				bomb.x = self.x;
				bomb.y = self.y;
				game.addChild(bomb);
				bombs.push(bomb);
			}
		}
	};
	return self;
});
/** 
* Represents a Bouncy Ball that bounces around the screen dealing damage to enemies.
*/ 
var BouncyBall = Container.expand(function () {
	var self = Container.call(this);
	// Create and attach the bouncy ball graphic asset (reusing cannonball for now)
	var graphics = self.attachAsset('cannonball', {
		anchorX: 0.5,
		anchorY: 0.5,
		scaleX: 1.5,
		scaleY: 1.5
	});
	graphics.tint = 0xFF00FF; // Magenta tint for bouncy ball
	self.speed = 15; // Base speed
	self.damage = 20; // Massive damage
	self.vx = (Math.random() - 0.5) * self.speed * 2; // Random initial horizontal velocity
	self.vy = -Math.abs((Math.random() - 0.5) * self.speed * 2); // Initial upward velocity
	self.lifetime = 600; // 10 seconds lifetime (600 ticks)
	self.lifetimeTimer = 0;
	self.bounceCount = 0; // Track number of bounces
	self.maxBounces = 20; // Maximum bounces before disappearing
	/** 
	* Update method called each game tick by the LK engine.
	* Handles movement, bouncing, and lifetime.
	*/ 
	self.update = function () {
		self.lifetimeTimer++;
		// Check lifetime
		if (self.lifetimeTimer >= self.lifetime || self.bounceCount >= self.maxBounces) {
			self.destroy();
			return;
		}
		// Move
		self.x += self.vx;
		self.y += self.vy;
		// Bounce off walls
		if (self.x <= graphics.width / 2 || self.x >= GAME_WIDTH - graphics.width / 2) {
			self.vx = -self.vx; // Reverse horizontal direction
			self.x = Math.max(graphics.width / 2, Math.min(GAME_WIDTH - graphics.width / 2, self.x));
			self.bounceCount++;
			// Flash on bounce
			LK.effects.flashObject(self, 0xFFFFFF, 200);
		}
		// Bounce off top and bottom
		if (self.y <= graphics.height / 2 || self.y >= BASTION_Y - graphics.height / 2) {
			self.vy = -self.vy; // Reverse vertical direction
			self.y = Math.max(graphics.height / 2, Math.min(BASTION_Y - graphics.height / 2, self.y));
			self.bounceCount++;
			// Flash on bounce
			LK.effects.flashObject(self, 0xFFFFFF, 200);
		}
	};
	return self;
});
/** 
	* Represents a Cannon ally that targets the strongest enemy.
	*/ 
var Cannon = Container.expand(function () {
	var self = Container.call(this);
	// Create and attach the cannon graphic asset (need to add a new asset for this)
	// Use dragon slayer cannon asset if mode is enabled, otherwise use regular cannon asset
	var assetId = self.dragonSlayerMode ? 'dragon_slayer_cannon_asset' : 'cannon_asset';
	var graphics = self.attachAsset(assetId, {
		// Use actual cannon asset
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.attackRange = 800; // Long attack range
	self.attackDamage = 10; // High damage
	self.attackInterval = 300; // Attack every 5 seconds (300 ticks)
	self.attackTimer = 0; // Timer for attacks
	self.rotation = 0; // For aiming visual if implemented later
	self.dragonSlayerMode = false; // Flag to indicate if this cannon is a dragon slayer cannon
	/** 
	* Update method called each game tick by the LK engine.
	* Handles attacking the strongest enemy.
	*/ 
	self.update = function () {
		self.attackTimer++;
		var effectiveAttackInterval = Math.max(60, self.attackInterval * allyAttackSpeedMultiplier); // Apply ally attack speed upgrade
		if (self.attackTimer >= effectiveAttackInterval) {
			self.attackTimer = 0; // Reset timer
			var targetEnemy = null;
			if (self.dragonSlayerMode) {
				// In dragon slayer mode, prioritize dragons
				var closestDragon = null;
				var closestDragonDistance = Infinity;
				var strongestNonDragon = null;
				var maxNonDragonHealth = -1;
				for (var i = 0; i < enemies.length; i++) {
					var enemy = enemies[i];
					if (enemy.tag === 'Dragon') {
						// Check distance for dragons
						var dx = enemy.x - self.x;
						var dy = enemy.y - self.y;
						var distance = Math.sqrt(dx * dx + dy * dy);
						if (distance < closestDragonDistance) {
							closestDragonDistance = distance;
							closestDragon = enemy;
						}
					} else {
						// Track strongest non-dragon as fallback
						if (enemy.health > maxNonDragonHealth) {
							maxNonDragonHealth = enemy.health;
							strongestNonDragon = enemy;
						}
					}
				}
				// Prioritize dragon if found, otherwise target strongest non-dragon
				targetEnemy = closestDragon || strongestNonDragon;
			} else {
				// Normal mode: find the strongest enemy (highest health)
				var maxHealth = -1;
				for (var i = 0; i < enemies.length; i++) {
					var enemy = enemies[i];
					if (enemy.health > maxHealth) {
						maxHealth = enemy.health;
						targetEnemy = enemy;
					}
				}
			}
			// If a target enemy is found within range, attack it
			if (targetEnemy) {
				// Calculate angle towards the target enemy
				var angle = Math.atan2(targetEnemy.x - self.x, -(targetEnemy.y - self.y));
				// Create a new cannonball instance, passing the dragon slayer mode status
				var newCannonball = new Cannonball(angle);
				newCannonball.dragonSlayerMode = self.dragonSlayerMode; // Pass the mode status
				// Position the cannonball at the cannon's location
				newCannonball.x = self.x;
				newCannonball.y = self.y;
				newCannonball.lastY = newCannonball.y; // Initialize lastY for state tracking
				newCannonball.lastX = newCannonball.x; // Initialize lastX for state tracking
				// If dragon slayer mode and targeting a dragon, apply damage bonus
				if (self.dragonSlayerMode && targetEnemy.tag === 'Dragon') {
					newCannonball.dragonDamageMultiplier = 25; // 25x damage to dragons
					// The Cannonball class will handle the asset and tint based on the mode.
				}
				// Add the cannonball to the game scene and the tracking array.
				game.addChild(newCannonball);
				cannonballs.push(newCannonball); // Add to the new cannonballs array
				// Optional: Add a visual/sound effect for cannon shot here later
			}
		}
	};
	return self; // Return self for potential inheritance
});
/** 
	* Represents a Cannonball fired by a Cannon.
	* @param {number} angle - The angle in radians at which the cannonball is fired.
	*/ 
var Cannonball = Container.expand(function (angle) {
	var self = Container.call(this);
	// Create and attach the graphic asset (rocket if dragon slayer mode, otherwise cannonball)
	var assetId = self.dragonSlayerMode ? 'rocket_asset' : 'cannonball';
	var graphics = self.attachAsset(assetId, {
		anchorX: 0.5,
		anchorY: 0.5
	});
	graphics.rotation = angle + Math.PI / 2; // Align graphic with direction
	// Apply red tint for rocket if in dragon slayer mode
	if (self.dragonSlayerMode) {
		graphics.tint = 0xFF0000; // Red tint for dragon slayer rockets
	}
	self.dragonSlayerMode = false; // Flag to indicate if this is a dragon slayer rocket
	self.dragonDamageMultiplier = 1; // Default damage multiplier
	self.speed = 20; // Base speed of the cannonball
	self.damage = 10; // Base damage dealt by this cannonball
	// Apply refined projectiles bonus if enabled
	if (refinedProjectilesEnabled) {
		self.speed += 5;
		self.damage += 5;
	}
	self.vx = Math.sin(angle) * self.speed; // Horizontal velocity component
	self.vy = -Math.cos(angle) * self.speed; // Vertical velocity component (negative Y is up)
	/** 
	* Update method called each game tick by the LK engine.
	* Moves the cannonball based on its velocity.
	*/ 
	self.update = function () {
		self.x += self.vx;
		self.y += self.vy;
	};
	return self; // Return self for potential inheritance
});
/** 
* Represents a Dart projectile fired by a Dart Ally.
* @param {number} angle - The angle in radians at which the dart is fired.
*/ 
var Dart = Container.expand(function (angle) {
	var self = Container.call(this);
	// Create and attach the dart graphic asset (reusing arrow for simplicity)
	// Will need a dedicated asset for the Dart if available.
	var graphics = self.attachAsset('dart_asset', {
		// Placeholder asset
		anchorX: 0.5,
		anchorY: 0.5
	});
	graphics.tint = 0x9933CC; // Purple tint for darts
	graphics.rotation = angle + Math.PI / 2; // Align dart graphic with direction
	self.speed = 40; // Fast speed
	self.damage = 0.5; // Base damage dealt by this dart
	// Apply refined projectiles bonus if enabled
	if (refinedProjectilesEnabled) {
		self.speed += 5;
		self.damage += 5;
	}
	self.vx = Math.sin(angle) * self.speed; // Horizontal velocity component
	self.vy = -Math.cos(angle) * self.speed; // Vertical velocity component (negative Y is up)
	/** 
	* Update method called each game tick by the LK engine.
	* Moves the dart based on its velocity.
	*/ 
	self.update = function () {
		self.x += self.vx;
		self.y += self.vy;
	};
	return self; // Return self for potential inheritance
});
/** 
* Represents a Dart Ally that shoots fast darts.
*/ 
var DartAlly = Container.expand(function () {
	var self = Container.call(this);
	// Create and attach the dart ally graphic asset (reusing archer asset for simplicity)
	// Will need a dedicated asset for the Dart Ally if available.
	var graphics = self.attachAsset('disguised_swordsman', {
		// Placeholder asset
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.attackRange = Infinity; // Infinite attack range
	self.attackDamage = 0.5; // Low damage per dart
	self.attackInterval = 30; // Attack every 0.5 seconds (30 ticks) - very fast
	self.attackTimer = 0; // Timer for attacks
	/** 
	* Update method called each game tick by the LK engine.
	* Handles finding targets and shooting darts.
	*/ 
	self.update = function () {
		self.attackTimer++;
		var effectiveAttackInterval = Math.max(10, self.attackInterval * allyAttackSpeedMultiplier); // Apply ally attack speed upgrade, min 0.16s
		if (self.attackTimer >= effectiveAttackInterval) {
			self.attackTimer = 0; // Reset timer
			// Find the closest enemy to shoot at
			var closestEnemy = null;
			var closestDistance = Infinity;
			for (var i = 0; i < enemies.length; i++) {
				var enemy = enemies[i];
				// Calculate distance to the enemy
				var dx = enemy.x - self.x;
				var dy = enemy.y - self.y;
				var distance = Math.sqrt(dx * dx + dy * dy);
				if (distance < closestDistance) {
					closestDistance = distance;
					closestEnemy = enemy;
				}
			}
			// If an enemy is found, shoot a dart
			if (closestEnemy) {
				// Calculate angle towards the closest enemy
				var angle = Math.atan2(closestEnemy.x - self.x, -(closestEnemy.y - self.y));
				// Create a new dart instance
				var newDart = new Dart(angle);
				newDart.x = self.x;
				newDart.y = self.y;
				newDart.lastY = newDart.y;
				newDart.lastX = newDart.x;
				// Add the dart to the game scene and the tracking array.
				game.addChild(newDart);
				darts.push(newDart); // Add to the new darts array
				// Optional: Add throwing sound effect here later
			}
		}
	};
	return self; // Return self for potential inheritance
});
/** 
	* Represents an Enemy attacker moving towards the bastion.
	* @param {string} type - The type of enemy ('swordsman', 'knight', 'thief', 'boss', 'shield', 'wizard', 'elite_knight').
* @param {number} speed - The final calculated speed of the enemy.
* @param {number} health - The initial and maximum health of the enemy.
* @param {number} dodgeChance - The chance (0 to 1) for the enemy to dodge an attack.
*/ 
var Enemy = Container.expand(function (type, speed, health, dodgeChance) {
	var self = Container.call(this);
	// Set asset based on type
	var assetId = 'enemy'; // Default swordsman asset
	if (type === 'knight') {
		assetId = 'knight';
	} else if (type === 'elite_knight') {
		assetId = 'elite_knight_asset'; // Use specific asset for elite knight
	} else if (type === 'thief') {
		assetId = 'thief';
	} else if (type === 'boss') {
		assetId = 'boss';
	} else if (type === 'shield') {
		assetId = 'shield_enemy'; // Use specific asset for shield
	} else if (type === 'wizard') {
		assetId = 'wizard_enemy'; // Use specific asset for wizard
	} else if (type === 'spearman') {
		assetId = 'spearman'; // Use specific asset for spearman
	} else if (type === 'war_elephant') {
		assetId = 'war_elephant'; // Use specific asset for war elephant
	} else if (type === 'elite_shield') {
		assetId = 'elite_shield_asset'; // Use specific asset for elite shield
	} else if (type === 'shaman') {
		assetId = 'shaman_enemy'; // Use specific asset for shaman
	} else if (type === 'hot_air_balloon') {
		assetId = 'hot_air_balloon_asset'; // Use specific asset for hot air balloon
	} else if (type === 'dark_bowman') {
		assetId = 'dark_bowman_asset'; // Use specific asset for dark bowman
	} else if (type === 'jester') {
		assetId = 'jester_asset'; // Use specific asset for jester
	} else if (type === 'dark_war_elephant') {
		assetId = 'dark_war_elephant_asset'; // Use specific asset for dark war elephant
	} else if (type === 'dark_spearman') {
		assetId = 'dark_spearman_asset'; // Use specific asset for dark spearman
	} else if (type === 'dragon') {
		assetId = 'dragon_asset'; // Use specific asset for dragon
	} else if (type === 'flag_bearer') {
		assetId = 'flag_bearer_asset'; // Use specific asset for flag bearer
	} else if (type === 'baby_dragon') {
		assetId = 'baby_dragon_asset'; // Use specific baby dragon asset
	}
	var graphics = self.attachAsset(assetId, {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.type = type; // 'swordsman', 'knight', 'thief', 'boss', 'shield', 'wizard', 'elite_knight', 'shaman', etc.
	self.speed = speed; // Final calculated speed
	self.health = health;
	self.maxHealth = health; // Store max health for visual feedback
	self.dodgeChance = dodgeChance || 0; // Default to 0 if undefined
	self.reflectChance = type === 'jester' ? 0.20 : 0; // 20% reflect chance, added in Enemy class
	self.poisonStacks = 0; // Number of poison stacks
	self.poisonTimer = 0; // Timer for poison damage
	self.poisonDamagePerTick = 0.05; // Damage per tick per stack
	self.slowTimer = 0; // Timer for slowdown effect
	self.currentSlowAmount = 1.0; // Multiplier for current slowdown effect (1.0 means no slow)
	// Initialize shaman-specific properties
	if (type === 'shaman') {
		self.shamanTimer = 0;
	}
	// Set tag property based on type
	self.tag = null; // Default tag is null
	if (self.type === 'wizard' || self.type === 'spearman' || self.type === 'war_elephant' || self.type === 'shaman') {
		self.tag = 'Green';
	} else if (self.type === 'dark_bowman' || self.type === 'dark_war_elephant' || self.type === 'dark_spearman') {
		self.tag = 'Black'; // Black-tagged enemies are immune to arrows and cannonballs
	}
	// Wizard-specific properties
	if (self.type === 'wizard') {
		self.teleportTimer = 0;
		self.teleportInterval = 180; // 3 seconds * 60 FPS
	}
	// --- Public Methods (defined before use) ---
	/** 
	* Update method called each game tick by the LK engine.
	* Moves the enemy downwards (or teleports for wizard) and updates visual feedback.
	*/ 
	self.update = function () {
		if (self.type === 'wizard') {
			self.teleportTimer = (self.teleportTimer || 0) + 1; // Initialize timer if needed
			if (self.teleportTimer >= self.teleportInterval) {
				self.teleportTimer = 0;
				// Teleport logic: Random X, slightly advanced Y
				var oldY = self.y;
				var teleportPadding = graphics.width / 2 + 20; // Use actual graphic width
				var newX = teleportPadding + Math.random() * (GAME_WIDTH - 2 * teleportPadding);
				// Advance Y slightly, but don't teleport past bastion
				var newY = Math.min(BASTION_Y - graphics.height, self.y + 100 + Math.random() * 100); // Advance 100-200px
				// Ensure not teleporting backwards significantly or offscreen top
				newY = Math.max(graphics.height / 2, newY);
				self.x = newX;
				self.y = newY;
				self.lastY = oldY; // Set lastY to pre-teleport position to avoid false bastion triggers
				// Add a visual effect for teleport
				LK.effects.flashObject(self, 0xAA00FF, 300); // Purple flash
			} else {
				// Move normally if not teleporting this frame
				self.y += self.speed;
			}
		} else {
			// Normal movement for other enemy types
			var effectiveSpeed = self.speed * self.currentSlowAmount;
			// Apply global slowdown relic if enabled and not a Dragon
			if (playerRelics.slowdown.enabled && self.tag !== 'Dragon') {
				effectiveSpeed *= 1 - playerRelics.slowdown.level * 0.02; // Apply global slow
			}
			// Apply Green Relic slowdown if enabled and enemy is Green-tagged and not a Dragon
			if (playerRelics.green.enabled && self.tag === 'Green' && self.tag !== 'Dragon') {
				effectiveSpeed *= 1 - playerRelics.green.level * 0.02; // Apply Green Relic slow
			}
			self.y += effectiveSpeed; // Apply slowdown to movement
		}
		// Decrease slowdown timer and reset slow amount if timer runs out
		if (self.slowTimer > 0) {
			self.slowTimer--;
			if (self.slowTimer <= 0) {
				self.currentSlowAmount = 1.0; // Reset speed multiplier when slowdown ends
				// Optional: Remove visual feedback for slowdown here later
			}
		}
		// Apply poison damage if stacks exist
		if (self.poisonStacks > 0) {
			self.poisonTimer++;
			if (self.poisonTimer >= 30) {
				// Apply poison damage every 0.5 seconds (30 ticks)
				self.poisonTimer = 0;
				var poisonDmg = self.poisonStacks * self.poisonDamagePerTick * 30; // Damage per 0.5s
				self.health -= poisonDmg;
				// Optional: Add visual feedback for poison damage here later
			}
			// Check if health dropped to zero or below due to poison
			if (self.health <= 0 && self.parent) {
				// Ensure enemy is still in the game
				// Enemy defeated by poison
				LK.setScore(LK.getScore() + 1); // Increment score.
				scoreTxt.setText(LK.getScore()); // Update score display.
				// Destroy the enemy
				self.destroy();
				// The main game update loop needs to handle removing the enemy from the `enemies` array
				return; // Stop updating this destroyed instance
			}
		}
		// Visual feedback based on health - alpha fade (applies to all types)
		var healthRatio = self.maxHealth > 0 ? self.health / self.maxHealth : 0;
		graphics.alpha = 0.4 + healthRatio * 0.6; // Fade from 1.0 down to 0.4
		// Shaman ability: reduce player ammo periodically
		if (self.type === 'shaman') {
			if (self.shamanTimer === undefined) {
				self.shamanTimer = 0;
			}
			self.shamanTimer += 1;
			var shamanAbilityInterval = 300; // 5 seconds * 60 FPS
			if (self.shamanTimer >= shamanAbilityInterval) {
				self.shamanTimer = 0;
				// Reduce player ammo, but not below 0
				arrowsFired = Math.min(maxArrowsBeforeCooldown, arrowsFired + 1); // Make it require one more shot for reload
				ammoTxt.setText('Ammo: ' + (maxArrowsBeforeCooldown - arrowsFired));
				// Optional: Add a visual/sound effect for shaman ability
			}
		}
	}; //{N} // Adjusted line identifier
	/** 
	* Method called when the enemy is hit by an arrow.
	* Handles dodging and health reduction.
	* @param {number} damage - The amount of damage the arrow deals.
	* @returns {boolean} - True if the enemy is defeated, false otherwise.
	*/ 
	self.takeDamage = function (damage) {
		var source = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
		// Add source parameter, default to null
		// Check for dodge first (only if dodgeChance is positive)
		if (self.dodgeChance > 0 && Math.random() < self.dodgeChance) {
			// Optional: Add a visual effect for dodge here later
			// console.log(self.type + " dodged!");
			return false; // Dodged, so not defeated by this hit
		}
		// Check for reflection (only for Jester and non-cannonball projectiles)
		if (self.type === 'jester' && self.reflectChance > 0 && Math.random() < self.reflectChance && !(source instanceof Cannonball)) {
			// Optional: Add a visual effect for reflection here later
			// console.log(self.type + " reflected!");
			// Projectile is destroyed, enemy takes no damage
			if (source && source.destroy) {
				source.destroy();
				// Need to remove from the source array in the main game loop
			}
			return false; // Reflected, so not defeated by this hit
		}
		// Check if enemy is Black-tagged and source is an Arrow or Cannonball
		if (self.tag === 'Black' && (source instanceof Arrow || source instanceof Cannonball)) {
			// Black-tagged enemies are immune to arrow and cannonball projectiles
			// Unless Dark Relic is enabled
			if (!playerRelics.dark.enabled) {
				return false; // Not defeated, projectile has no effect
			}
		}
		var finalDamage = damage;
		// Apply damage relic bonus if enabled
		if (playerRelics.damage.enabled) {
			finalDamage += playerRelics.damage.level;
		}
		// Apply Green Relic damage bonus if enabled and enemy is Green-tagged
		if (playerRelics.green.enabled && self.tag === 'Green') {
			finalDamage *= 1 + playerRelics.green.level * 0.2;
		}
		// Apply Dark Relic damage bonus if enabled and enemy is Black-tagged
		if (playerRelics.dark.enabled && self.tag === 'Black' && (source instanceof Arrow || source instanceof Cannonball)) {
			finalDamage *= 1 + playerRelics.dark.level * 0.05;
		}
		self.health -= finalDamage;
		// Check if the damage source was a poison arrow and apply poison stacks
		if (source && source.isPoison) {
			// Use the 'source' parameter
			self.poisonStacks++; // Increase poison stacks
			self.poisonTimer = 0; // Reset timer to apply damage immediately
		}
		// Check if the damage source was a Magic Ball and apply slowdown
		if (source && source instanceof MagicBall) {
			if (self.tag !== 'Dragon') {
				// Dragons are immune to slowdowns
				self.slowTimer = source.slowDuration; // Apply slowdown duration
				self.currentSlowAmount = source.slowAmount; // Apply slowdown amount
				// Optional: Add visual feedback for slowdown here later
			}
		}
		// Check if the damage source was an Arrow and apply Dragon relic stun
		if (playerRelics.dragon.enabled && source instanceof Arrow && self.tag === 'Dragon') {
			// Apply stun (reusing slowTimer for duration, 0.0 for 100% slow)
			var stunDuration = 0.25 * 60 + playerRelics.dragon.level * 0.05 * 60; // Base 0.25s + 0.05s per level
			self.slowTimer = Math.max(self.slowTimer, stunDuration);
			self.currentSlowAmount = 0.0; // 100% slow (stun)
		}
		// Check if the damage source should apply Green Slowdown
		if (greenSlowdownEnabled && self.tag === 'Green' && self.slowTimer <= 0 && self.tag !== 'Dragon') {
			// Dragons are immune to slowdowns
			// Apply Green Slowdown only if the upgrade is active, enemy is Green, not already slowed, and not a Dragon
			self.slowTimer = 10 * 60; // 10 seconds * 60 ticks/sec
			self.currentSlowAmount = 0.9; // 10% slowdown
			// Optional: Add visual feedback for green slowdown
		}
		// Check if enemy was defeated by this damage
		var defeated = self.health <= 0;
		if (defeated && self.type === 'war_elephant') {
			// If War Elephant is defeated, spawn 5 spearmen
			for (var i = 0; i < 5; i++) {
				var spawnPadding = 100; // Padding from edge
				var spawnX = self.x + (Math.random() * 200 - 100); // Spawn around elephant's x
				var spawnY = self.y + (Math.random() * 100 - 50); // Spawn around elephant's y, slightly forward
				// Ensure spawns are within game bounds
				spawnX = Math.max(spawnPadding, Math.min(GAME_WIDTH - spawnPadding, spawnX));
				spawnY = Math.max(spawnPadding, Math.min(BASTION_Y - 50, spawnY)); // Don't spawn too close to bastion
				var newSpearman = new Enemy('spearman', currentEnemySpeed * enemySpeedMultiplier, 2, 0); // Base spearman stats
				newSpearman.x = spawnX;
				newSpearman.y = spawnY;
				newSpearman.lastY = newSpearman.y;
				game.addChild(newSpearman);
				enemies.push(newSpearman);
			}
		} else if (defeated && self.type === 'dark_war_elephant') {
			// If Dark War Elephant is defeated, spawn 5 Dark Bowmen
			for (var i = 0; i < 5; i++) {
				var spawnPadding = 100; // Padding from edge
				var spawnX = self.x + (Math.random() * 200 - 100); // Spawn around elephant's x
				var spawnY = self.y + (Math.random() * 100 - 50); // Spawn around elephant's y, slightly forward
				// Ensure spawns are within game bounds
				spawnX = Math.max(spawnPadding, Math.min(GAME_WIDTH - spawnPadding, spawnX));
				spawnY = Math.max(spawnPadding, Math.min(BASTION_Y - 50, spawnY)); // Don't spawn too close to bastion
				var newDarkBowman = new Enemy('dark_bowman', currentEnemySpeed * enemySpeedMultiplier, 5, 0); // Base dark bowman stats
				newDarkBowman.x = spawnX;
				newDarkBowman.y = spawnY;
				newDarkBowman.lastY = newDarkBowman.y;
				game.addChild(newDarkBowman);
				enemies.push(newDarkBowman);
			}
		} else if (defeated && self.type === 'hot_air_balloon') {
			// If Hot Air Balloon is defeated, spawn 5 random non-green enemies
			var possibleTypes = ['swordsman', 'knight', 'thief', 'shield', 'elite_knight', 'elite_shield', 'dark_bowman'];
			for (var i = 0; i < 5; i++) {
				// Choose random enemy type that is not green-tagged
				var randomType = possibleTypes[Math.floor(Math.random() * possibleTypes.length)];
				var randomHP = 1 + Math.floor(Math.random() * 5); // Random HP between 1-5
				var randomSpeed = currentEnemySpeed * 0.7 * enemySpeedMultiplier; // Slower than average
				var newEnemy = new Enemy(randomType, randomSpeed, randomHP, 0);
				// Spawn in a staggered pattern below the balloon
				var spawnPadding = 100;
				var spawnX = self.x + (Math.random() * 300 - 150); // Wider spread than elephant
				var spawnY = self.y + Math.random() * 200; // Always below the balloon
				// Ensure spawns are within game bounds
				spawnX = Math.max(spawnPadding, Math.min(GAME_WIDTH - spawnPadding, spawnX));
				spawnY = Math.min(BASTION_Y - 50, spawnY); // Don't spawn too close to bastion
				newEnemy.x = spawnX;
				newEnemy.y = spawnY;
				newEnemy.lastY = newEnemy.y;
				game.addChild(newEnemy);
				enemies.push(newEnemy);
			}
		}
		// No need to update alpha here, self.update handles it
		return defeated; // Return true if health is 0 or less
	}; //{O} // Adjusted line identifier
	// --- Initialization ---
	// Apply visual distinctions based on type
	graphics.tint = 0xFFFFFF; // Reset tint
	graphics.scale.set(1.0); // Reset scale
	if (self.type === 'knight') {
		graphics.tint = 0xCCCCCC; // Grey tint for Knights
		graphics.scale.set(1.1);
	} else if (self.type === 'elite_knight') {
		graphics.tint = 0xFFD700; // Gold tint for Elite Knights
		graphics.scale.set(1.2); // Slightly larger than normal knight
	} else if (self.type === 'thief') {
		graphics.tint = 0xCCFFCC; // Pale Green tint for Thieves
		graphics.scale.set(0.9);
	} else if (self.type === 'boss') {
		graphics.tint = 0xFFCCCC; // Pale Red tint for Bosses
		graphics.scale.set(1.4); // Make bosses quite large
	} else if (self.type === 'shield') {
		graphics.tint = 0xADD8E6; // Light Blue tint for Shield
		graphics.scale.set(1.2); // Make shield enemies bulky
	} else if (self.type === 'wizard') {
		graphics.tint = 0xE0B0FF; // Light Purple tint for Wizard
		graphics.scale.set(1.0);
	} else if (self.type === 'elite_shield') {
		graphics.tint = 0x8A2BE2; // Blue Violet tint for Elite Shield
		graphics.scale.set(1.3); // Slightly larger than normal shield
	} else if (self.type === 'jester') {
		graphics.tint = 0xFFB6C1; // Light Pink tint for Jester
		graphics.scale.set(1.0);
	} else if (self.type === 'dark_war_elephant') {
		graphics.tint = 0x333333; // Dark Grey tint for Dark War Elephant
		graphics.scale.set(1.4); // Same size as regular elephant
	} else if (self.type === 'dark_spearman') {
		graphics.scale.set(1.05); // Slightly larger than regular spearman
	} else if (self.type === 'dragon') {
		graphics.scale.set(1.6); // Dragons are large
	} //{11} // Modified original line identifier location
	return self; // Return self for potential inheritance
});
/** 
	* Represents a Flag Bearer enemy that provides a speed boost aura to nearby enemies.
	*/ 
var FlagBearer = Container.expand(function () {
	var self = Container.call(this);
	// Create and attach the flag bearer graphic asset
	var graphics = self.attachAsset('flag_bearer_asset', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// No tint applied to flag bearer
	self.type = 'flag_bearer';
	self.speed = 3; // Base speed (will be set from spawn)
	self.health = 5; // Base health (will be set from spawn)
	self.maxHealth = 5;
	self.dodgeChance = 0;
	self.tag = 'Green'; // Green-tagged enemy
	self.auraRadius = 300; // Radius of speed boost aura
	self.auraBoost = 1.5; // 50% speed boost to enemies in aura
	self.poisonStacks = 0;
	self.poisonTimer = 0;
	self.poisonDamagePerTick = 0.05;
	self.slowTimer = 0;
	self.currentSlowAmount = 1.0;
	// Create aura visual effect
	self.auraCircle = self.attachAsset('light_effect_asset', {
		anchorX: 0.5,
		anchorY: 0.5,
		width: self.auraRadius * 2,
		height: self.auraRadius * 2,
		tint: 0x00FF00,
		alpha: 0.2
	});
	// Position aura behind the flag bearer
	self.setChildIndex(self.auraCircle, 0);
	/** 
	* Update method called each game tick by the LK engine.
	* Moves the flag bearer and applies aura effects.
	*/ 
	self.update = function () {
		// Normal movement
		self.y += self.speed * self.currentSlowAmount;
		// Apply aura effect to nearby enemies
		for (var i = 0; i < enemies.length; i++) {
			var enemy = enemies[i];
			if (enemy === self) {
				continue;
			} // Skip self
			var dx = enemy.x - self.x;
			var dy = enemy.y - self.y;
			var distance = Math.sqrt(dx * dx + dy * dy);
			if (distance <= self.auraRadius) {
				// Enemy is within aura range
				if (!enemy.hasAuraBoost) {
					enemy.hasAuraBoost = true;
					enemy.baseSpeed = enemy.speed;
					enemy.speed = enemy.baseSpeed * self.auraBoost;
				}
			} else if (enemy.hasAuraBoost) {
				// Enemy left aura range
				enemy.hasAuraBoost = false;
				enemy.speed = enemy.baseSpeed || enemy.speed;
			}
		}
		// Handle slowdown timer
		if (self.slowTimer > 0) {
			self.slowTimer--;
			if (self.slowTimer <= 0) {
				self.currentSlowAmount = 1.0;
			}
		}
		// Apply poison damage
		if (self.poisonStacks > 0) {
			self.poisonTimer++;
			if (self.poisonTimer >= 30) {
				self.poisonTimer = 0;
				var poisonDmg = self.poisonStacks * self.poisonDamagePerTick * 30;
				self.health -= poisonDmg;
			}
			if (self.health <= 0 && self.parent) {
				LK.setScore(LK.getScore() + 1);
				scoreTxt.setText(LK.getScore());
				self.destroy();
				return;
			}
		}
		// Visual feedback based on health
		var healthRatio = self.maxHealth > 0 ? self.health / self.maxHealth : 0;
		graphics.alpha = 0.4 + healthRatio * 0.6;
		// Update aura visual effect
		if (self.auraCircle) {
			self.auraCircle.x = self.x;
			self.auraCircle.y = self.y;
			// Pulse effect
			self.auraPulseTimer = (self.auraPulseTimer || 0) + 0.05;
			var pulseScale = 1.0 + Math.sin(self.auraPulseTimer) * 0.1;
			self.auraCircle.scale.set(pulseScale);
			self.auraCircle.alpha = 0.15 + Math.sin(self.auraPulseTimer * 2) * 0.05;
		}
	};
	/** 
	* Method called when the flag bearer takes damage.
	*/ 
	self.takeDamage = function (damage, source) {
		// Check for dodge
		if (self.dodgeChance > 0 && Math.random() < self.dodgeChance) {
			return false;
		}
		// Check if source is Arrow or Cannonball (Green enemies are not immune)
		self.health -= damage;
		// Apply poison if applicable
		if (source && source.isPoison) {
			self.poisonStacks++;
			self.poisonTimer = 0;
		}
		// Apply slowdown from Magic Ball
		if (source && source instanceof MagicBall) {
			self.slowTimer = source.slowDuration;
			self.currentSlowAmount = source.slowAmount;
		}
		// Apply Green Slowdown
		if (greenSlowdownEnabled && self.tag === 'Green' && self.slowTimer <= 0) {
			self.slowTimer = 10 * 60;
			self.currentSlowAmount = 0.9;
		}
		return self.health <= 0;
	};
	// Clean up aura effects when destroyed
	var originalDestroy = self.destroy;
	self.destroy = function () {
		// Remove aura effects from all enemies
		for (var i = 0; i < enemies.length; i++) {
			var enemy = enemies[i];
			if (enemy.hasAuraBoost) {
				enemy.hasAuraBoost = false;
				enemy.speed = enemy.baseSpeed || enemy.speed;
			}
		}
		// Clean up aura visual
		if (self.auraCircle) {
			self.auraCircle.destroy();
			self.auraCircle = null;
		}
		originalDestroy.call(self);
	};
	return self;
});
/** 
	* Represents a Magic Ball projectile fired by a Wizard Tower.
	* @param {number} angle - The angle in radians at which the magic ball is fired.
	*/ 
var MagicBall = Container.expand(function (angle) {
	var self = Container.call(this);
	// Create and attach the magic ball graphic asset
	var graphics = self.attachAsset('magic_ball_asset', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	graphics.rotation = angle + Math.PI / 2; // Align magic ball graphic with direction
	self.speed = 15; // Base speed of the magic ball
	self.damage = 2; // Base damage dealt by this magic ball
	// Apply refined projectiles bonus if enabled
	if (refinedProjectilesEnabled) {
		self.speed += 5;
		self.damage += 5;
	}
	self.vx = Math.sin(angle) * self.speed; // Horizontal velocity component
	self.vy = -Math.cos(angle) * self.speed; // Vertical velocity component (negative Y is up)
	self.slowDuration = 0; // Duration of slowdown applied on hit
	self.slowAmount = 0; // Multiplier for enemy speed on hit
	self.targetEnemy = null; // Track the specific enemy the magic ball is seeking
	self.seekSpeed = 0.05; // How quickly the magic ball adjusts its direction to seek
	/** 
	* Update method called each game tick by the LK engine.
	* Moves the magic ball based on its velocity and seeks target if Aimbot is enabled.
	*/ 
	self.update = function () {
		if (aimbotEnabled && self.targetEnemy && self.targetEnemy.parent) {
			// If aimbot is enabled, a target exists and is still in the game, seek it
			var targetAngle = Math.atan2(self.targetEnemy.x - self.x, -(self.targetEnemy.y - self.y));
			// Smoothly adjust the magic ball's angle towards the target angle
			var angleDiff = targetAngle - (self.rotation - Math.PI / 2); // Difference considering graphic rotation
			// Normalize angle difference to be between -PI and PI
			if (angleDiff > Math.PI) {
				angleDiff -= 2 * Math.PI;
			}
			if (angleDiff < -Math.PI) {
				angleDiff += 2 * Math.PI;
			}
			// Interpolate angle
			var newAngle = self.rotation - Math.PI / 2 + angleDiff * self.seekSpeed;
			self.rotation = newAngle + Math.PI / 2;
			self.vx = Math.sin(newAngle) * self.speed;
			self.vy = -Math.cos(newAngle) * self.speed;
		} else if (aimbotEnabled && (!self.targetEnemy || !self.targetEnemy.parent)) {
			// If aimbot is enabled but current target is gone, find a new target
			self.targetEnemy = null; // Clear old target
			var closestEnemy = null;
			var closestDistance = Infinity;
			for (var i = 0; i < enemies.length; i++) {
				var enemy = enemies[i];
				var dx = enemy.x - self.x;
				var dy = enemy.y - self.y;
				var distance = Math.sqrt(dx * dx + dy * dy);
				if (distance < closestDistance) {
					closestDistance = distance;
					closestEnemy = enemy;
				}
			}
			if (closestEnemy) {
				self.targetEnemy = closestEnemy;
			}
		}
		self.x += self.vx;
		self.y += self.vy;
	};
	return self; // Return self for potential inheritance
});
/** 
* Represents a Swordsman ally that attacks enemies in melee range.
*/ 
var Swordsman = Container.expand(function () {
	var self = Container.call(this);
	// Create and attach the swordsman graphic asset (reusing enemy asset for simplicity)
	var graphics = self.attachAsset('swordsmanAlly', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// No tint needed as ally asset has unique colors
	graphics.scale.set(1.0); // Use the asset's intended scale
	self.attackRange = 150; // Melee attack range
	self.attackDamage = 1; // Damage per hit
	self.attackInterval = 60; // Attack every 1 second (60 ticks)
	self.attackTimer = 0; // Timer for attacks
	self.lifetime = 10 * 60; // Lifetime in ticks (10 seconds * 60 ticks/sec)
	self.lifetimeTimer = 0; // Timer for lifetime
	/** 
	* Update method called each game tick by the LK engine.
	* Handles attacking and lifetime.
	*/ 
	self.update = function () {
		self.attackTimer++;
		self.lifetimeTimer++;
		// Check for lifetime
		var effectiveAttackInterval = Math.max(30, self.attackInterval * allyAttackSpeedMultiplier); // Apply ally attack speed upgrade, min 0.5s
		if (self.lifetimeTimer >= self.lifetime) {
			self.destroy();
			// Remove from the swordsmen array in the main game loop
			return; // Stop updating this instance
		}
		// Find the closest enemy to chase or attack
		var closestEnemy = null;
		var closestDistance = Infinity;
		for (var i = 0; i < enemies.length; i++) {
			var enemy = enemies[i];
			// Calculate distance to the enemy
			var dx = enemy.x - self.x;
			var dy = enemy.y - self.y;
			var distance = Math.sqrt(dx * dx + dy * dy);
			if (distance < closestDistance) {
				closestDistance = distance;
				closestEnemy = enemy;
			}
		}
		// If an enemy exists, chase it or attack if within range
		if (closestEnemy) {
			// Movement speed toward enemies
			var moveSpeed = 5;
			// If not within attack range, move toward the enemy
			if (closestDistance > self.attackRange) {
				// Calculate direction vector to enemy
				var dirX = closestEnemy.x - self.x;
				var dirY = closestEnemy.y - self.y;
				// Normalize the direction vector
				var length = Math.sqrt(dirX * dirX + dirY * dirY);
				dirX = dirX / length;
				dirY = dirY / length;
				// Move toward the enemy
				self.x += dirX * moveSpeed;
				self.y += dirY * moveSpeed;
			}
			// If within attack range and attack timer is ready, attack
			else if (self.attackTimer >= effectiveAttackInterval) {
				self.attackTimer = 0; // Reset timer
				// Apply damage to the enemy and check if it was defeated
				var finalSwordsmanDamage = self.attackDamage;
				// Apply damage relic bonus if enabled
				if (playerRelics.damage.enabled) {
					finalSwordsmanDamage += playerRelics.damage.level;
				}
				var enemyDefeated = closestEnemy.takeDamage(finalSwordsmanDamage, self); // Pass the swordsman as source
				if (enemyDefeated) {
					LK.setScore(LK.getScore() + 1); // Increment score when enemy is defeated by swordsman.
					scoreTxt.setText(LK.getScore()); // Update score display.
					// Destroy the enemy
					closestEnemy.destroy();
					// Remove from the enemies array in the main game loop
				}
				// Optional: Add a visual/sound effect for attack here later
			}
		}
	};
	return self; // Return self for potential inheritance
});
/** 
* Represents a Viking ally that throws piercing axes.
*/ 
var VikingAlly = Container.expand(function () {
	var self = Container.call(this);
	var graphics = self.attachAsset('viking_ally', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.attackRange = Infinity; // Infinite attack range
	self.attackInterval = 150; // Attack every 2.5 seconds (150 ticks)
	self.attackTimer = 0; // Timer for attacks
	/** 
	* Update method called each game tick by the LK engine.
	* Handles finding targets and throwing axes.
	*/ 
	self.update = function () {
		self.attackTimer++;
		var effectiveAttackInterval = Math.max(60, self.attackInterval * allyAttackSpeedMultiplier); // Apply ally attack speed upgrade
		if (self.attackTimer >= effectiveAttackInterval) {
			self.attackTimer = 0; // Reset timer
			// Find the closest enemy within range
			var closestEnemy = null;
			var closestDistance = self.attackRange;
			for (var i = 0; i < enemies.length; i++) {
				var enemy = enemies[i];
				var dx = enemy.x - self.x;
				var dy = enemy.y - self.y;
				var distance = Math.sqrt(dx * dx + dy * dy);
				if (distance < closestDistance) {
					closestDistance = distance;
					closestEnemy = enemy;
				}
			}
			// If an enemy is found, throw an axe
			if (closestEnemy) {
				var angle = Math.atan2(closestEnemy.x - self.x, -(closestEnemy.y - self.y));
				var newAxe = new VikingAxe(angle);
				newAxe.x = self.x;
				newAxe.y = self.y;
				newAxe.lastY = newAxe.y;
				newAxe.lastX = newAxe.x;
				game.addChild(newAxe);
				vikingAxes.push(newAxe); // Add to the vikingAxes array
				// Optional: Add throwing sound effect here later
			}
		}
	};
	return self;
});
/** 
* Represents an Axe thrown by a Viking Ally.
* @param {number} angle - The angle in radians at which the axe is thrown.
*/ 
var VikingAxe = Container.expand(function (angle) {
	var self = Container.call(this);
	var graphics = self.attachAsset('viking_axe', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	graphics.rotation = angle + Math.PI / 2; // Align axe graphic with direction
	self.speed = 25; // Speed of the axe
	// Apply refined projectiles bonus if enabled
	if (refinedProjectilesEnabled) {
		self.speed += 5;
	}
	self.vx = Math.sin(angle) * self.speed; // Horizontal velocity component
	self.vy = -Math.cos(angle) * self.speed; // Vertical velocity component (negative Y is up)
	self.damage = 3; // Base damage dealt by this axe
	// Apply refined projectiles bonus if enabled
	if (refinedProjectilesEnabled) {
		self.damage += 5;
	}
	self.pierceLeft = 3; // Can pierce through 3 enemies
	/** 
	* Update method called each game tick by the LK engine.
	* Moves the axe based on its velocity and handles rotation.
	*/ 
	self.update = function () {
		self.x += self.vx;
		self.y += self.vy;
		graphics.rotation += 0.2; // Add spinning effect
	};
	return self;
});
/** 
	* Represents a Wizard Tower ally that shoots magic balls.
	*/ 
var WizardTower = Container.expand(function () {
	var self = Container.call(this);
	// Create and attach the wizard tower graphic asset
	var graphics = self.attachAsset('wizard_tower_asset', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.attackRange = Infinity; // Infinite attack range
	self.attackDamage = 0.5; // Low damage, primary effect is slowdown
	self.attackInterval = 120; // Attack every 2 seconds (120 ticks)
	self.attackTimer = 0; // Timer for attacks
	self.slowDuration = 180; // Duration of slowdown effect in ticks (3 seconds)
	self.slowAmount = 0.5; // Multiplier for enemy speed (0.5 means 50% slower)
	/** 
	* Update method called each game tick by the LK engine.
	* Handles attacking enemies.
	*/ 
	self.update = function () {
		self.attackTimer++;
		var effectiveAttackInterval = Math.max(60, self.attackInterval * allyAttackSpeedMultiplier); // Apply ally attack speed upgrade
		if (self.attackTimer >= effectiveAttackInterval) {
			self.attackTimer = 0; // Reset timer
			// Find the closest enemy within range to shoot at
			var closestEnemy = null;
			var closestDistance = self.attackRange; // Limit to attack range
			for (var i = 0; i < enemies.length; i++) {
				var enemy = enemies[i];
				// Calculate distance to the enemy
				var dx = enemy.x - self.x;
				var dy = enemy.y - self.y;
				var distance = Math.sqrt(dx * dx + dy * dy);
				if (distance < closestDistance) {
					closestDistance = distance;
					closestEnemy = enemy;
				}
			}
			// If an enemy is found, fire a magic ball
			if (closestEnemy) {
				// Calculate angle towards the closest enemy
				var angle = Math.atan2(closestEnemy.x - self.x, -(closestEnemy.y - self.y));
				// Create a new magic ball instance
				var newMagicBall = new MagicBall(angle);
				// Position the magic ball at the tower's location
				newMagicBall.x = self.x;
				newMagicBall.y = self.y;
				newMagicBall.lastY = newMagicBall.y; // Initialize lastY for state tracking
				newMagicBall.lastX = newMagicBall.x; // Initialize lastX for state tracking
				newMagicBall.slowDuration = self.slowDuration; // Pass slow duration to the magic ball
				newMagicBall.slowAmount = self.slowAmount; // Pass slow amount to the magic ball
				// Add the magic ball to the game scene and the tracking array.
				game.addChild(newMagicBall);
				magicBalls.push(newMagicBall); // Add to the magicBalls array
				// Optional: Add a visual/sound effect for magic ball shot here later
			}
		}
	};
	return self; // Return self for potential inheritance
});
/** 
* Represents an XBOW (crossbow) ally that rapidly shoots arrows.
*/ 
var XBOW = Container.expand(function () {
	var self = Container.call(this);
	// Create and attach the XBOW graphic asset
	var graphics = self.attachAsset('xbow_asset', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.fireInterval = 20; // Very rapid fire (every 0.33 seconds)
	self.fireTimer = 0;
	self.targetingMode = 'closest_to_bastion'; // Default targeting mode
	self.smartTargetingEnabled = false; // Flag for smart targeting upgrade
	self.tintApplied = false; // Track if tint has been applied
	/** 
	* Update method called each game tick by the LK engine.
	* Handles rapid firing logic.
	*/ 
	self.update = function () {
		self.fireTimer++;
		var baseInterval = self.smartTargetingEnabled ? 15.36 : self.fireInterval; // 0.256 seconds when smart targeting enabled
		var effectiveFireInterval = Math.max(10, baseInterval * allyAttackSpeedMultiplier);
		if (self.fireTimer >= effectiveFireInterval) {
			self.fireTimer = 0;
			// Find target based on targeting mode
			var target = null;
			if (self.smartTargetingEnabled) {
				// Apply green tint when smart targeting is enabled
				if (!self.tintApplied) {
					graphics.tint = 0x00FF00; // Green tint
					self.tintApplied = true;
				}
				if (self.targetingMode === 'closest_to_bastion') {
					// Find enemy closest to bastion
					var closestDistance = Infinity;
					for (var i = 0; i < enemies.length; i++) {
						var enemy = enemies[i];
						var distanceToBastion = BASTION_Y - enemy.y;
						if (distanceToBastion > 0 && distanceToBastion < closestDistance) {
							closestDistance = distanceToBastion;
							target = enemy;
						}
					}
				} else if (self.targetingMode === 'strongest') {
					// Find enemy with highest health
					var maxHealth = -1;
					for (var i = 0; i < enemies.length; i++) {
						var enemy = enemies[i];
						if (enemy.health > maxHealth) {
							maxHealth = enemy.health;
							target = enemy;
						}
					}
				}
			}
			// Default behavior: shoot at center of screen
			var angle;
			if (target) {
				// Calculate angle towards target
				angle = Math.atan2(target.x - self.x, -(target.y - self.y));
			} else {
				// No target or smart targeting disabled - shoot straight up towards center
				angle = 0; // 0 radians = straight up
			}
			// Create arrow
			var newArrow = new Arrow(angle);
			newArrow.x = self.x;
			newArrow.y = self.y;
			newArrow.lastY = newArrow.y;
			newArrow.lastX = newArrow.x;
			// XBOW arrows are faster
			newArrow.speed *= 1.5;
			newArrow.vx = Math.sin(angle) * newArrow.speed;
			newArrow.vy = -Math.cos(angle) * newArrow.speed;
			// Disable aimbot for XBOW arrows
			newArrow.targetEnemy = null;
			game.addChild(newArrow);
			arrows.push(newArrow);
			// Apply multi-shot if enabled
			if (multiShotEnabled) {
				// Fire a second arrow with a slight angle offset
				var angle2 = angle + Math.PI / 12; // Offset by 15 degrees
				var newArrow2 = new Arrow(angle2);
				newArrow2.x = self.x;
				newArrow2.y = self.y;
				newArrow2.lastY = newArrow2.y;
				newArrow2.lastX = newArrow2.x;
				// XBOW arrows are faster
				newArrow2.speed *= 1.5;
				newArrow2.vx = Math.sin(angle2) * newArrow2.speed;
				newArrow2.vy = -Math.cos(angle2) * newArrow2.speed;
				// Disable aimbot for XBOW arrows
				newArrow2.targetEnemy = null;
				game.addChild(newArrow2);
				arrows.push(newArrow2);
				// Fire a third arrow with the opposite angle offset
				var angle3 = angle - Math.PI / 12; // Offset by -15 degrees
				var newArrow3 = new Arrow(angle3);
				newArrow3.x = self.x;
				newArrow3.y = self.y;
				newArrow3.lastY = newArrow3.y;
				newArrow3.lastX = newArrow3.x;
				// XBOW arrows are faster
				newArrow3.speed *= 1.5;
				newArrow3.vx = Math.sin(angle3) * newArrow3.speed;
				newArrow3.vy = -Math.cos(angle3) * newArrow3.speed;
				// Disable aimbot for XBOW arrows
				newArrow3.targetEnemy = null;
				game.addChild(newArrow3);
				arrows.push(newArrow3);
			}
		}
	};
	return self;
});

/**** 
* Initialize Game
****/ 
// Create the main game instance with a dark background color.
var game = new LK.Game({
	backgroundColor: 0x101030 // Dark blue/purple background
});

/**** 
* Game Code
****/ 
// Use actual war elephant asset
// Use actual spearman asset
// Placeholder ID, adjust size slightly, reuse flipX
// Placeholder ID
// Placeholder ID, adjust size slightly
// Constants defining game dimensions and key vertical positions.
//var facekit = LK.import('@upit/facekit.v1');
//Library for using the camera (the background becomes the user's camera video feed) and the microphone. It can access face coordinates for interactive play, as well detect microphone volume / voice interactions
//var storage = LK.import('@upit/storage.v1');
//Storage library which should be used for persistent game data
//We have access to the following plugins. (Note that the variable names used are mandetory for each plugin)
//Only include the plugins you need to create the game.
//Minimalistic tween library which should be used for animations over time, including tinting / colouring an object, scaling, rotating, or changing any game object property.
var GAME_WIDTH = 2048;
var GAME_HEIGHT = 2732;
var BASTION_Y = GAME_HEIGHT - 250; // Y-coordinate representing the defense line. Enemies crossing this trigger game over.
var FIRING_POS_Y = GAME_HEIGHT - 150; // Y-coordinate from where arrows are fired.
var FIRING_POS_X = GAME_WIDTH / 2; // X-coordinate from where arrows are fired (center).
// Arrays to keep track of active arrows and enemies.
var arrows = [];
var enemies = [];
// Variables for game state and difficulty scaling.
var scoreTxt; // Text2 object for displaying the score.
var ammoTxt; // Text2 object for displaying the current ammo count.
var dragStartX = null; // Starting X coordinate of a touch/mouse drag.
var dragStartY = null; // Starting Y coordinate of a touch/mouse drag.
var enemySpawnInterval = 120; // Initial ticks between enemy spawns (2 seconds at 60 FPS).
var arrowsFired = 0; // Counter for arrows fired since the last cooldown.
var cooldownTimer = 0; // Timer in ticks for the cooldown period.
var cooldownDuration = 6 * 60; // Cooldown duration in ticks (6 seconds * 60 ticks/sec). Min duration enforced in upgrade.
var baseMaxArrowsBeforeCooldown = 15; // Base max arrows before reload (Quiver upgrade)
var maxArrowsBeforeCooldown = baseMaxArrowsBeforeCooldown; // Max arrows before reload
var ammoRelicTimer = 0; // Timer for ammo relic regeneration
var arrowPierceLevel = 1; // How many enemies an arrow can pierce (Piercing Shots upgrade)
var arrowDamage = 1; // Base damage for arrows (Heat-tipped arrows upgrade)
var enemySpeedMultiplier = 1.0; // Multiplier for enemy speed (Sabotage upgrade) Min multiplier enforced in upgrade.
var minEnemySpawnInterval = 30; // Minimum ticks between enemy spawns (0.5 seconds).
var enemySpawnRateDecrease = 0.08; // Amount to decrease spawn interval each time an enemy spawns.
var currentEnemySpeed = 3; // Initial base speed of enemies.
var maxEnemySpeed = 12; // Maximum base speed enemies can reach.
var enemySpeedIncrease = 0.015; // Amount to increase enemy base speed each time an enemy spawns.
var archerAllies = []; // Array to hold ArcherAlly instances
var swordsmen = []; // Array to hold Swordsman instances
var cannonballs = []; // Array to hold Cannonball instances
var multiShotEnabled = false; // Flag for More Shots upgrade
var poisonShotsEnabled = false; // Flag for Poison Shots upgrade
var cannons = []; // Array to hold Cannon instances
var allyAttackSpeedMultiplier = 1.0; // Multiplier for ally attack speed
var wizardTowers = []; // Array to hold WizardTower instances
var magicBalls = []; // Array to hold MagicBall instances
var aimbotEnabled = false; // Flag for Aimbot upgrade
var greenKillerEnabled = false; // Flag for Green Killer upgrade
var refinedProjectilesEnabled = false; // Flag for Refined Projectiles upgrade
var greenSlowdownEnabled = false; // Flag for Green Slowdown upgrade
var vikingAllies = []; // Array to hold VikingAlly instances
var vikingAxes = []; // Array to hold VikingAxe instances
var darts = []; // Array to hold Dart instances
var angelOfLights = []; // Array to hold AngelOfLight instances
var bouncyBalls = []; // Array to hold BouncyBall instances
var bombs = []; // Array to hold Bomb instances
var bombers = []; // Array to hold Bomber instances
var xbows = []; // Array to hold XBOW instances
var xbowSmartTargetingEnabled = false; // Flag for XBOW Smart Targeting upgrade
var battleHornEnabled = false; // Flag for Battle Horn upgrade
var dragonSlayerCannonsModeEnabled = false; // Flag for Dragon Slayer Cannons upgrade
// --- Relics and Gold System ---
var playerGold = storage.playerGold || 0; // Load gold from storage, default to 0
// Load relics from storage using flat format
var storedRelicsData = storage.playerRelicsData || {};
var playerRelics = {
	damage: {
		level: storedRelicsData.damage_level || 0,
		enabled: storedRelicsData.damage_enabled || false
	},
	slowdown: {
		level: storedRelicsData.slowdown_level || 0,
		enabled: storedRelicsData.slowdown_enabled || false
	},
	green: {
		level: storedRelicsData.green_level || 0,
		enabled: storedRelicsData.green_enabled || false
	},
	dark: {
		level: storedRelicsData.dark_level || 0,
		enabled: storedRelicsData.dark_enabled || false
	},
	dragon: {
		level: storedRelicsData.dragon_level || 0,
		enabled: storedRelicsData.dragon_enabled || false
	},
	reload: {
		level: storedRelicsData.reload_level || 0,
		enabled: storedRelicsData.reload_enabled || false
	},
	ammo: {
		level: storedRelicsData.ammo_level || 0,
		enabled: storedRelicsData.ammo_enabled || false
	},
	swordsman: {
		level: storedRelicsData.swordsman_level || 0,
		enabled: storedRelicsData.swordsman_enabled || false
	}
};
var RELIC_MAX_LEVEL = 10;
var RELIC_COST_PER_LEVEL = 5; // 5 gold per level
// --- Upgrade System ---
var lastUpgradeScore = -1; // Score at which the last upgrade was offered
var isUpgradePopupActive = false; // Flag indicating if the upgrade choice popup is visible
var upgradePopup = null; // Container for the upgrade UI elements
var currentMusicPlaying = 'Gamemusic'; // Track which music is currently playing
var musicFadeInProgress = false; // Flag to track if a music fade transition is in progress
// Helper function to apply Sabotage effect to existing enemies
function applySabotage() {
	for (var i = 0; i < enemies.length; i++) {
		// We assume Enemy class will use enemySpeedMultiplier when calculating effective speed
		// If Enemy.speed stores base speed, we might need an effectiveSpeed method or update speed directly.
		// For simplicity, let's assume Enemy.update uses the global multiplier.
		// If direct modification is needed: enemies[i].speed = baseSpeed * enemySpeedMultiplier;
	}
	// Also update the current base speed calculation baseline if necessary, though modifying the multiplier should suffice.
}
// Helper function placeholder for adding Archer Ally
function addArcherAlly() {
	// Implementation requires ArcherAlly class definition
	console.log("Archer Ally upgrade chosen!");
	var ally = new ArcherAlly();
	// Position the ally next to the player's firing position, slightly offset.
	ally.x = FIRING_POS_X + 150; // Position to the right of the player
	ally.y = FIRING_POS_Y;
	game.addChild(ally);
	archerAllies.push(ally); // Add to the new archerAllies array
}
// Helper function to add a Cannon ally
function addCannon() {
	console.log("Cannon upgrade chosen!");
	var newCannon = new Cannon();
	// Position the cannon near the bastion line
	newCannon.x = GAME_WIDTH / 2 - 300; // Example position to the left of center
	newCannon.y = BASTION_Y - 100; // Position above the bastion line
	// Apply dragon slayer mode if the global flag is enabled
	newCannon.dragonSlayerMode = dragonSlayerCannonsModeEnabled;
	game.addChild(newCannon);
	cannons.push(newCannon); // Add to the cannons array
}
// Helper function to add a Wizard Tower
function addWizardTower() {
	console.log("Wizard Tower upgrade chosen!");
	var newTower = new WizardTower();
	// Position the wizard tower near the bastion line, offset from center
	newTower.x = GAME_WIDTH / 2 + 300; // Example position to the right of center
	newTower.y = BASTION_Y - 100; // Position above the bastion line
	game.addChild(newTower);
	wizardTowers.push(newTower); // Add to the wizardTowers array
}
// Helper function to add a Viking Ally
function addVikingAlly() {
	console.log("Viking Ally upgrade chosen!");
	var newViking = new VikingAlly();
	// Position the viking near the bastion line, offset from cannons/towers
	newViking.x = GAME_WIDTH / 2; // Center for now
	newViking.y = BASTION_Y - 100; // Position above the bastion line
	game.addChild(newViking);
	vikingAllies.push(newViking); // Add to the vikingAllies array
}
// Helper function to add a Dart Ally
function addDartAlly() {
	console.log("Dart Ally upgrade chosen!");
	var newDartAlly = new DartAlly();
	// Position the dart ally near the bastion line, offset
	newDartAlly.x = GAME_WIDTH / 2 - 200; // Example position
	newDartAlly.y = BASTION_Y - 100; // Position above bastion line
	game.addChild(newDartAlly);
	darts.push(newDartAlly); // Add to the dartAllies array (need to rename array to dartAllies if creating a separate one)
}
// Helper function placeholder for adding Swordsman
function addSwordsman() {
	// Create a swordsman tower at the bastion line
	var tower = new Container();
	var towerGraphics = tower.attachAsset('swordsmanTower', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	tower.x = FIRING_POS_X; // Position in the center horizontally
	tower.y = BASTION_Y - 50; // Position just above the bastion line
	game.addChild(tower);
	// Set up interval to spawn swordsmen from the tower
	var spawnInterval = LK.setInterval(function () {
		var newSwordsman = new Swordsman();
		// Position the swordsman near the tower with a slight random offset
		newSwordsman.x = tower.x + (Math.random() * 100 - 50); // Random offset of ±50px
		newSwordsman.y = tower.y;
		game.addChild(newSwordsman);
		swordsmen.push(newSwordsman); // Add to the swordsmen array
	}, 3000); // Spawn a swordsman every 3 seconds
	// Swordsman spawn does not grant score
	// Store the interval reference in the tower to potentially clear it later
	tower.spawnInterval = spawnInterval;
}
// Helper function to add an Angel of Light
function addAngelOfLight() {
	console.log("Angel of Light upgrade chosen!");
	var newAngel = new AngelOfLight();
	// Position the angel near the bastion line, offset
	newAngel.x = GAME_WIDTH / 2 + 200; // Example position
	newAngel.y = BASTION_Y - 150; // Position slightly higher than other allies
	game.addChild(newAngel);
	angelOfLights.push(newAngel); // Add to the angelOfLights array
}
// Helper function to add a Bouncy Ball
function addBouncyBall() {
	console.log("Bouncy Ball upgrade chosen!");
	var newBall = new BouncyBall();
	// Start from center of screen
	newBall.x = GAME_WIDTH / 2;
	newBall.y = GAME_HEIGHT / 2;
	game.addChild(newBall);
	bouncyBalls.push(newBall);
}
// Helper function to add a Bomber
function addBomber() {
	console.log("Bomber upgrade chosen!");
	var newBomber = new Bomber();
	// Position near bastion line
	newBomber.x = GAME_WIDTH / 2 - 400;
	newBomber.y = BASTION_Y - 100;
	game.addChild(newBomber);
	bombers.push(newBomber);
}
// Helper function to add an XBOW
function addXBOW() {
	console.log("XBOW upgrade chosen!");
	var newXBOW = new XBOW();
	// Position at the center of the bastion
	newXBOW.x = GAME_WIDTH / 2;
	newXBOW.y = BASTION_Y - 100;
	game.addChild(newXBOW);
	xbows.push(newXBOW);
}
// Helper function to enable XBOW Smart Targeting
function enableXBOWSmartTargeting() {
	console.log("XBOW Smart Targeting upgrade chosen!");
	xbowSmartTargetingEnabled = true;
	// Enable smart targeting for all existing XBOWs
	for (var i = 0; i < xbows.length; i++) {
		xbows[i].smartTargetingEnabled = true;
		// Randomly assign targeting mode for variety
		xbows[i].targetingMode = Math.random() < 0.5 ? 'closest_to_bastion' : 'strongest';
	}
}
// Define all possible upgrades
var allUpgrades = [{
	id: 'faster_reload',
	name: 'Faster Reload',
	description: 'Decrease reload time by 20%',
	apply: function apply() {
		cooldownDuration = Math.max(60, Math.floor(cooldownDuration * 0.8));
	}
},
// Min 1 sec cooldown
{
	id: 'piercing_shots',
	name: 'Piercing Shots',
	description: 'Arrows pierce +1 enemy',
	apply: function apply() {
		arrowPierceLevel++;
	}
}, {
	id: 'quiver',
	name: 'Quiver',
	description: '+5 Arrows before reload',
	apply: function apply() {
		maxArrowsBeforeCooldown += 5;
	}
}, {
	id: 'heat_tipped',
	name: 'Heat-tipped Arrows',
	description: 'Arrows deal +1 damage',
	apply: function apply() {
		arrowDamage += 1;
		console.log("Heat-tipped Arrows upgrade chosen - damage increased to " + arrowDamage);
	}
}, {
	id: 'archer_ally',
	name: 'Archer Ally',
	description: 'Gain an allied archer',
	apply: addArcherAlly
}, {
	id: 'sabotage',
	name: 'Sabotage',
	description: 'Enemies 10% slower',
	apply: function apply() {
		enemySpeedMultiplier = Math.max(0.5, enemySpeedMultiplier * 0.9);
		applySabotage();
	}
},
// Max 50% slow
{
	id: 'swordsman',
	name: 'Swordsman',
	description: 'Gain a melee defender',
	apply: addSwordsman
}, {
	id: 'more_shots',
	name: 'More Shots',
	description: 'Shoot 2 arrows at once',
	apply: function apply() {
		multiShotEnabled = true; // Assuming a global flag for this
	}
}, {
	id: 'poison_shots',
	name: 'Poison Shots',
	description: 'Shots deal damage over time',
	apply: function apply() {
		poisonShotsEnabled = true; // Assuming a global flag for this
	}
}, {
	id: 'cannon',
	name: 'Cannon',
	description: 'Gain a cannon that targets the strongest enemy',
	apply: addCannon // Assuming a helper function addCannon
}, {
	id: 'ally_atk_speed',
	name: 'Ally ATK Speed',
	description: 'All allies attack faster',
	apply: function apply() {
		allyAttackSpeedMultiplier *= 0.8; // Assuming a global multiplier
		// Apply to existing allies as well in their update logic or a helper function
	}
}, {
	id: 'wizard_tower',
	name: 'Wizard Tower',
	description: 'Gain a wizard tower ally that shoots magic balls that slowdown enemies',
	apply: addWizardTower // Assuming a helper function addWizardTower
}, {
	id: 'aimbot',
	name: 'Aimbot',
	description: 'Arrows seek out enemies',
	apply: function apply() {
		aimbotEnabled = true; // Assuming a global flag for this
	}
}, {
	id: 'green_killer',
	name: 'Green Killer',
	description: '+50% Damage vs Green Enemies',
	apply: function apply() {
		greenKillerEnabled = true;
	}
}, {
	id: 'refined_projectiles',
	name: 'Refined Projectiles',
	description: 'Non-arrow projectiles +5 damage & faster',
	apply: function apply() {
		refinedProjectilesEnabled = true;
		// Existing projectiles won't update, new ones will have bonus
	}
}, {
	id: 'viking_ally',
	name: 'Viking Ally',
	description: 'Gain a viking that throws piercing axes',
	apply: addVikingAlly // Assuming helper function addVikingAlly
}, {
	id: 'green_slowdown',
	name: 'Green Slowdown',
	description: 'Projectiles slow Green enemies 10% for 10s (no stack)',
	apply: function apply() {
		greenSlowdownEnabled = true;
	}
}, {
	id: 'dart_shooter',
	name: 'Dart Shooter',
	description: 'Gain an ally that shoots fast darts, effective against green enemies',
	apply: addDartAlly // Assuming a helper function addDartAlly
}, {
	id: 'angel_of_light',
	name: 'Angel of Light',
	description: 'Gain an ally that stuns enemies and deals high damage to dark enemies',
	apply: addAngelOfLight // Assuming a helper function addAngelOfLight
}, {
	id: 'bouncy_ball',
	name: 'Bouncy Ball',
	description: 'Bounces around dealing massive damage to enemies',
	apply: addBouncyBall
}, {
	id: 'bomber',
	name: 'Bomber',
	description: 'Throws bombs that explode for area damage',
	apply: addBomber
}, {
	id: 'xbow',
	name: 'XBOW',
	description: 'A big bow that rapidly shoots arrows',
	apply: addXBOW
}, {
	id: 'xbow_smart_targeting',
	name: 'XBOW Smart Targeting',
	description: 'XBOWs can target closest to bastion or strongest enemy',
	apply: enableXBOWSmartTargeting
}, {
	id: 'dragon_slayer_cannons',
	name: 'Dragon Slayer Cannons',
	description: 'Cannons become rocket launchers that deal 25x damage to dragons and prioritize them',
	apply: function apply() {
		// Enable dragon slayer mode for all existing cannons
		for (var i = 0; i < cannons.length; i++) {
			cannons[i].dragonSlayerMode = true;
		}
		// Set global flag so all future cannons will have dragon slayer mode
		dragonSlayerCannonsModeEnabled = true;
	}
}, {
	id: 'battle_horn',
	name: 'Battle Horn',
	description: 'More enemies spawn, but they are all swordsmen: more score for more upgrades!',
	apply: function apply() {
		// Reduce spawn interval for more enemies
		enemySpawnInterval = Math.max(15, enemySpawnInterval * 0.5); // 50% faster spawning, min 0.25 seconds
		// Set global flag to force swordsman spawns
		battleHornEnabled = true;
	}
}];
// Function to create and show the upgrade selection popup
function showUpgradePopup() {
	isUpgradePopupActive = true;
	// Simple pause: Game logic checks isUpgradePopupActive flag in game.update
	// Switch to upgrade theme music with fade effect
	if (currentMusicPlaying !== 'UpgradeTheme' && !musicFadeInProgress) {
		musicFadeInProgress = true;
		// Fade out current music
		LK.playMusic('Gamemusic', {
			fade: {
				start: 1,
				end: 0,
				duration: 800
			}
		});
		// After fade out completes, start upgrade theme with fade in
		LK.setTimeout(function () {
			LK.playMusic('UpgradeTheme', {
				fade: {
					start: 0,
					end: 1,
					duration: 1000
				}
			});
			currentMusicPlaying = 'UpgradeTheme';
			musicFadeInProgress = false;
		}, 850);
	}
	// --- Create Popup UI ---
	upgradePopup = new Container();
	upgradePopup.x = GAME_WIDTH / 2;
	upgradePopup.y = GAME_HEIGHT / 2;
	game.addChild(upgradePopup); // Add to game layer for positioning relative to center
	// Add a semi-transparent background overlay
	var bg = upgradePopup.attachAsset('bastionLine', {
		// Reusing an asset for shape
		width: 1200,
		height: 800,
		color: 0x000000,
		// Black background
		anchorX: 0.5,
		anchorY: 0.5,
		alpha: 0.8
	});
	// Add title text
	var title = new Text2('Choose an Upgrade!', {
		size: 80,
		fill: 0xFFFFFF
	});
	title.anchor.set(0.5, 0.5);
	title.y = -300; // Position relative to popup center
	upgradePopup.addChild(title);
	// --- Select 3 Random Unique Upgrades ---
	var availableToOffer = allUpgrades.slice(); // Copy available upgrades
	var choices = [];
	var numChoices = Math.min(3, availableToOffer.length); // Offer up to 3 choices
	// Make dragon slayer cannons more common past score 100
	var currentScore = LK.getScore();
	if (currentScore > 100 && !dragonSlayerCannonsModeEnabled) {
		// Add dragon slayer cannons upgrade multiple times to increase chances
		var dragonSlayerUpgrade = null;
		for (var ds = 0; ds < availableToOffer.length; ds++) {
			if (availableToOffer[ds].id === 'dragon_slayer_cannons') {
				dragonSlayerUpgrade = availableToOffer[ds];
				break;
			}
		}
		if (dragonSlayerUpgrade) {
			// Add it 2 more times to the pool (3x total chance)
			availableToOffer.push(dragonSlayerUpgrade);
			availableToOffer.push(dragonSlayerUpgrade);
		}
	}
	for (var i = 0; i < numChoices; i++) {
		var randomIndex = Math.floor(Math.random() * availableToOffer.length);
		choices.push(availableToOffer[randomIndex]);
		availableToOffer.splice(randomIndex, 1); // Remove chosen upgrade to ensure uniqueness
	}
	// --- Create Buttons for Choices ---
	var buttonYStart = -150;
	var buttonSpacing = 180;
	for (var j = 0; j < choices.length; j++) {
		var upgrade = choices[j];
		var button = createUpgradeButton(upgrade, buttonYStart + j * buttonSpacing);
		upgradePopup.addChild(button);
	}
}
// Function to create a single upgrade button
function createUpgradeButton(upgradeData, yPos) {
	var buttonContainer = new Container();
	buttonContainer.y = yPos;
	// Button background
	var buttonBg = buttonContainer.attachAsset('bastionLine', {
		// Reusing asset for shape
		width: 800,
		height: 150,
		color: 0x555555,
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Button text (Name + Description)
	var nameText = new Text2(upgradeData.name, {
		size: 50,
		fill: 0xFFFFFF
	});
	nameText.anchor.set(0.5, 0.5);
	nameText.y = -25;
	buttonContainer.addChild(nameText);
	var descText = new Text2(upgradeData.description, {
		size: 35,
		fill: 0xCCCCCC
	});
	descText.anchor.set(0.5, 0.5);
	descText.y = 30;
	buttonContainer.addChild(descText);
	// Make button interactive
	buttonContainer.interactive = true; // Needed for down event
	// Event handler for button press
	buttonContainer.down = function (x, y, obj) {
		upgradeData.apply(); // Apply the selected upgrade's effect
		hideUpgradePopup(); // Close the popup
	};
	return buttonContainer;
}
// Function to hide and destroy the upgrade popup
function hideUpgradePopup() {
	if (upgradePopup) {
		upgradePopup.destroy();
		upgradePopup = null;
	}
	isUpgradePopupActive = false;
	// Switch back to game music with fade effect
	if (currentMusicPlaying !== 'Gamemusic' && !musicFadeInProgress) {
		musicFadeInProgress = true;
		// Fade out upgrade theme
		LK.playMusic('UpgradeTheme', {
			fade: {
				start: 1,
				end: 0,
				duration: 800
			}
		});
		// After fade out completes, start game music with fade in
		LK.setTimeout(function () {
			LK.playMusic('Gamemusic', {
				fade: {
					start: 0,
					end: 1,
					duration: 1000
				}
			});
			currentMusicPlaying = 'Gamemusic';
			musicFadeInProgress = false;
		}, 850);
	}
	// Resume game logic (handled by checking flag in game.update)
}
// --- Upgradepedia ---
var upgradepediaButton;
var upgradepediaPopup = null;
var upgradeListContainer = null;
function showUpgradepedia() {
	isUpgradePopupActive = true; // Pause the game while upgradepedia is open
	upgradepediaPopup = new Container();
	upgradepediaPopup.x = GAME_WIDTH / 2;
	upgradepediaPopup.y = GAME_HEIGHT / 2;
	game.addChild(upgradepediaPopup);
	// Add a semi-transparent background overlay
	var bg = upgradepediaPopup.attachAsset('pedia_screen_bg', {
		width: 1600,
		height: 2000,
		anchorX: 0.5,
		anchorY: 0.5,
		alpha: 0.9
	});
	// Add title text
	var title = new Text2('Upgradepedia', {
		size: 100,
		fill: 0xFFFFFF
	});
	title.anchor.set(0.5, 0.5);
	title.y = -900;
	upgradepediaPopup.addChild(title);
	// Add close button
	var closeButton = createUpgradepediaCloseButton();
	closeButton.x = 750;
	closeButton.y = -900;
	upgradepediaPopup.addChild(closeButton);
	// Container for upgrade details
	upgradeListContainer = new Container();
	upgradeListContainer.y = -200;
	upgradepediaPopup.addChild(upgradeListContainer);
	displayUpgradeStats();
}
function hideUpgradepedia() {
	if (upgradepediaPopup) {
		upgradepediaPopup.destroy();
		upgradepediaPopup = null;
	}
	isUpgradePopupActive = false; // Unpause the game
}
function createUpgradepediaCloseButton() {
	var buttonContainer = new Container();
	var buttonBg = buttonContainer.attachAsset('pedia_button_bg', {
		width: 150,
		height: 80,
		color: 0xCC0000,
		anchorX: 0.5,
		anchorY: 0.5
	});
	var buttonText = new Text2('X', {
		size: 60,
		fill: 0xFFFFFF
	});
	buttonText.anchor.set(0.5, 0.5);
	buttonContainer.addChild(buttonText);
	buttonContainer.interactive = true;
	buttonContainer.down = function () {
		hideUpgradepedia();
	};
	return buttonContainer;
}
function displayUpgradeStats() {
	// Clear any existing content
	while (upgradeListContainer.children.length > 0) {
		upgradeListContainer.removeChildAt(0);
	}
	// Current page tracking
	var currentUpgrade = 0;
	var totalUpgrades = allUpgrades.length;
	// Map upgrade IDs to visual assets and additional info
	var upgradeAssets = {
		'faster_reload': {
			asset: 'Reload',
			scale: 0.4
		},
		'piercing_shots': {
			asset: 'arrow',
			scale: 0.6
		},
		'quiver': {
			asset: 'arrow',
			scale: 0.8,
			tint: 0xFFD700
		},
		'heat_tipped': {
			asset: 'arrow',
			scale: 0.6,
			tint: 0xFF4500
		},
		'archer_ally': {
			asset: 'Archer',
			scale: 0.8
		},
		'sabotage': {
			asset: 'thief',
			scale: 0.8
		},
		'swordsman': {
			asset: 'swordsmanAlly',
			scale: 0.8
		},
		'more_shots': {
			asset: 'arrow',
			scale: 0.5,
			count: 3
		},
		'poison_shots': {
			asset: 'arrow',
			scale: 0.6,
			tint: 0x00FF00
		},
		'cannon': {
			asset: 'cannon_asset',
			scale: 0.8
		},
		'ally_atk_speed': {
			asset: 'viking_axe',
			scale: 0.6
		},
		'wizard_tower': {
			asset: 'wizard_tower_asset',
			scale: 0.8
		},
		'aimbot': {
			asset: 'arrow',
			scale: 0.6,
			special: 'seeking'
		},
		'green_killer': {
			asset: 'arrow',
			scale: 0.6,
			tint: 0xFF0000
		},
		'refined_projectiles': {
			asset: 'cannonball',
			scale: 0.6,
			tint: 0xFFD700
		},
		'viking_ally': {
			asset: 'viking_ally',
			scale: 0.8
		},
		'green_slowdown': {
			asset: 'magic_ball_asset',
			scale: 0.6,
			tint: 0x00FF00
		},
		'dart_shooter': {
			asset: 'dart_asset',
			scale: 0.8
		},
		'angel_of_light': {
			asset: 'angel_of_light_asset',
			scale: 0.8
		},
		'bouncy_ball': {
			asset: 'cannonball',
			scale: 1.0,
			tint: 0xFF00FF
		},
		'bomber': {
			asset: 'bomber_asset',
			scale: 0.8
		},
		'xbow': {
			asset: 'xbow_asset',
			scale: 0.8
		},
		'xbow_smart_targeting': {
			asset: 'xbow_asset',
			scale: 0.8,
			tint: 0x00FFFF
		},
		'dragon_slayer_cannons': {
			asset: 'cannon_asset',
			scale: 0.8,
			tint: 0xFF0000
		},
		'battle_horn': {
			asset: 'flag_bearer_asset',
			scale: 0.8,
			tint: 0xFFD700
		}
	};
	function displayUpgradeDetails(index) {
		// Clear existing content
		while (upgradeListContainer.children.length > 0) {
			upgradeListContainer.removeChildAt(0);
		}
		var upgradeInfo = allUpgrades[index];
		var assetInfo = upgradeAssets[upgradeInfo.id] || {
			asset: 'arrow',
			scale: 0.6
		};
		// Upgrade display container
		var upgradeDisplay = new Container();
		upgradeDisplay.y = 0;
		upgradeListContainer.addChild(upgradeDisplay);
		// Add upgrade graphic
		if (assetInfo.count) {
			// Special case for multiple projectiles
			for (var i = 0; i < assetInfo.count; i++) {
				var graphic = upgradeDisplay.attachAsset(assetInfo.asset, {
					anchorX: 0.5,
					anchorY: 0.5,
					scaleX: assetInfo.scale,
					scaleY: assetInfo.scale,
					x: -400 + (i - 1) * 100,
					y: 50
				});
				if (assetInfo.tint) {
					graphic.tint = assetInfo.tint;
				}
			}
		} else {
			var upgradeGraphic = upgradeDisplay.attachAsset(assetInfo.asset, {
				anchorX: 0.5,
				anchorY: 0.5,
				scaleX: assetInfo.scale,
				scaleY: assetInfo.scale,
				x: -400,
				y: 50
			});
			if (assetInfo.tint) {
				upgradeGraphic.tint = assetInfo.tint;
			}
			// Special visual effects
			if (assetInfo.special === 'seeking') {
				// Add rotation animation hint for seeking arrows
				upgradeGraphic.rotation = Math.PI / 6;
			}
		}
		// Add upgrade name
		var nameText = new Text2(upgradeInfo.name, {
			size: 70,
			fill: 0xFFFFFF
		});
		nameText.anchor.set(0.5, 0);
		nameText.x = 0;
		nameText.y = -400;
		upgradeDisplay.addChild(nameText);
		// Add description
		var descText = new Text2(upgradeInfo.description, {
			size: 45,
			fill: 0xCCCCCC,
			wordWrap: true,
			wordWrapWidth: 1200
		});
		descText.anchor.set(0.5, 0);
		descText.x = 0;
		descText.y = -300;
		upgradeDisplay.addChild(descText);
		// Add detailed ability description
		var abilityText = getDetailedAbility(upgradeInfo.id);
		var abilityDisplay = new Text2('Ability: ' + abilityText, {
			size: 40,
			fill: 0x88FF88,
			wordWrap: true,
			wordWrapWidth: 1200
		});
		abilityDisplay.anchor.set(0.5, 0);
		abilityDisplay.x = 0;
		abilityDisplay.y = -150;
		upgradeDisplay.addChild(abilityDisplay);
		// Status display
		var statusText = new Text2('Upgrade ' + (index + 1) + ' of ' + totalUpgrades, {
			size: 35,
			fill: 0xAAAAAA
		});
		statusText.anchor.set(0.5, 0);
		statusText.x = 0;
		statusText.y = 250;
		upgradeDisplay.addChild(statusText);
		// Navigation buttons
		var navButtons = new Container();
		navButtons.y = 350;
		upgradeDisplay.addChild(navButtons);
		// Previous button
		var prevButton = createUpgradeNavButton('← Previous', -250, function () {
			currentUpgrade = (currentUpgrade - 1 + totalUpgrades) % totalUpgrades;
			displayUpgradeDetails(currentUpgrade);
		});
		navButtons.addChild(prevButton);
		// Next button
		var nextButton = createUpgradeNavButton('Next →', 250, function () {
			currentUpgrade = (currentUpgrade + 1) % totalUpgrades;
			displayUpgradeDetails(currentUpgrade);
		});
		navButtons.addChild(nextButton);
	}
	function getDetailedAbility(upgradeId) {
		var abilities = {
			'faster_reload': 'Reduces the cooldown time between reloads by 20%. Stacks multiplicatively with minimum 1 second cooldown.',
			'piercing_shots': 'Each arrow can pierce through one additional enemy. Stacks to pierce multiple enemies.',
			'quiver': 'Increases maximum ammo capacity by 5 arrows before needing to reload.',
			'heat_tipped': 'Increases arrow damage by 1. Affects all arrow-based attacks including allies.',
			'archer_ally': 'Spawns an allied archer that independently targets and shoots at enemies every 3 seconds.',
			'sabotage': 'Reduces all enemy movement speed by 10%. Stacks multiplicatively with minimum 50% speed.',
			'swordsman': 'Creates a tower that spawns temporary swordsmen allies every 3 seconds. Swordsmen chase and attack nearby enemies.',
			'more_shots': 'Fire 3 arrows at once in a spread pattern. Works with all arrow upgrades.',
			'poison_shots': 'Arrows apply poison stacks that deal damage over time. Each stack deals damage every 0.5 seconds.',
			'cannon': 'Deploys a cannon that targets the strongest enemy and fires high-damage cannonballs every 5 seconds.',
			'ally_atk_speed': 'All allies attack 20% faster. Stacks multiplicatively.',
			'wizard_tower': 'Builds a tower that shoots magic balls causing slowdown effect on hit. Dragons are immune to slowdown.',
			'aimbot': 'Arrows and magic balls automatically seek the nearest enemy. Updates target if current target is destroyed.',
			'green_killer': 'Deal 50% extra damage to all Green-tagged enemies (Wizards, Spearmen, War Elephants, Shamans).',
			'refined_projectiles': 'Non-arrow projectiles (cannonballs, magic balls, axes) gain +5 damage and +5 speed.',
			'viking_ally': 'Summons a viking warrior that throws piercing axes. Each axe can pierce through 3 enemies.',
			'green_slowdown': 'Projectiles slow Green-tagged enemies by 10% for 10 seconds. Effect does not stack.',
			'dart_shooter': 'Deploys a rapid-fire dart shooter that deals double damage to Green enemies.',
			'angel_of_light': 'Summons an angel that stuns enemies for 5 seconds and deals triple damage to Black-tagged enemies. Dragons cannot be stunned.',
			'bouncy_ball': 'Releases a bouncing projectile that ricochets off walls dealing massive damage. Lasts 10 seconds or 20 bounces.',
			'bomber': 'Deploys a bomber that throws area damage bombs. Cannot directly target Dragons but explosion can damage them.',
			'xbow': 'Installs a large crossbow that rapidly fires arrows every 0.33 seconds. Arrows travel 50% faster.',
			'xbow_smart_targeting': 'XBOWs can now target either the enemy closest to bastion or the strongest enemy. All other allies have this by default.',
			'dragon_slayer_cannons': 'Transforms all current and future cannons into rocket launchers. Rockets deal 25x damage to Dragon-type enemies and prioritize targeting them over all other enemy types.',
			'battle_horn': 'Doubles enemy spawn rate but forces all spawned enemies to be basic swordsmen. Great for farming score since swordsmen are easy to defeat!'
		};
		return abilities[upgradeId] || 'Special ability that enhances your defenses.';
	}
	function createUpgradeNavButton(label, xPos, callback) {
		var button = new Container();
		button.x = xPos;
		var buttonBg = button.attachAsset('pedia_nav_button_bg', {
			width: 250,
			height: 80,
			anchorX: 0.5,
			anchorY: 0.5
		});
		var buttonText = new Text2(label, {
			size: 40,
			fill: 0xFFFFFF
		});
		buttonText.anchor.set(0.5, 0.5);
		button.addChild(buttonText);
		button.interactive = true;
		button.down = callback;
		return button;
	}
	// Initial display
	displayUpgradeDetails(currentUpgrade);
}
// Create upgradepedia button
upgradepediaButton = new Container();
upgradepediaButton.x = 200; // Position on the left side
upgradepediaButton.y = GAME_HEIGHT - 200;
// Add button background
var upgradeBtnBg = upgradepediaButton.attachAsset('pedia_button_bg', {
	width: 300,
	height: 100,
	anchorX: 0.5,
	anchorY: 0.5
});
// Add button text
var upgradeBtnText = new Text2('Upgradepedia', {
	size: 40,
	fill: 0xFFFFFF
});
upgradeBtnText.anchor.set(0.5, 0.5);
upgradepediaButton.addChild(upgradeBtnText);
// Make button interactive
upgradepediaButton.interactive = true;
upgradepediaButton.down = function () {
	showUpgradepedia();
};
// Add the button to the game scene
game.addChild(upgradepediaButton);
// --- Relic Shop Button ---
var relicShopButton = new Container();
relicShopButton.x = GAME_WIDTH - 200; // Position on the right side
relicShopButton.y = GAME_HEIGHT - 320; // Position above Enemypedia button
var relicBtnBg = relicShopButton.attachAsset('pedia_button_bg', {
	width: 300,
	height: 100,
	anchorX: 0.5,
	anchorY: 0.5
});
var relicBtnText = new Text2('Relic Shop', {
	size: 40,
	fill: 0xFFFFFF
});
relicBtnText.anchor.set(0.5, 0.5);
relicShopButton.addChild(relicBtnText);
relicShopButton.interactive = true;
relicShopButton.down = function () {
	showRelicShop();
};
game.addChild(relicShopButton);
// --- Visual Setup ---
var bastionLine = game.addChild(LK.getAsset('bastionLine', {
	anchorX: 0.0,
	// Anchor at the left edge.
	anchorY: 0.5,
	// Anchor vertically centered.
	x: 0,
	// Position at the left edge of the screen.
	y: BASTION_Y // Position at the defined bastion Y-coordinate.
}));
// Create and configure the score display text.
scoreTxt = new Text2('0', {
	size: 150,
	// Font size.
	fill: 0xFFFFFF // White color.
});
scoreTxt.anchor.set(0.5, 0); // Anchor at the horizontal center, top edge.
// Add score text to the GUI layer at the top-center position.
LK.gui.top.addChild(scoreTxt);
scoreTxt.y = 30; // Add padding below the top edge. Ensure it's clear of the top-left menu icon area.
// Create and configure the ammo display text.
ammoTxt = new Text2('Ammo: ' + maxArrowsBeforeCooldown, {
	size: 80,
	fill: 0xFFFFFF // White color.
});
ammoTxt.anchor.set(0.5, 0); // Anchor at the horizontal center, top edge.
LK.gui.top.addChild(ammoTxt);
ammoTxt.y = 180; // Position below the score text
// --- Enemypedia ---
var enemypediaButton;
var enemypediaPopup = null;
var enemyListContainer = null; // Container for enemy list items
function showEnemypedia() {
	isUpgradePopupActive = true; // Pause the game while enemypedia is open
	enemypediaPopup = new Container();
	enemypediaPopup.x = GAME_WIDTH / 2;
	enemypediaPopup.y = GAME_HEIGHT / 2;
	game.addChild(enemypediaPopup);
	// Add a semi-transparent background overlay
	var bg = enemypediaPopup.attachAsset('bastionLine', {
		width: 1600,
		height: 1200,
		// Increased height for better layout
		color: 0x000000,
		anchorX: 0.5,
		anchorY: 0.5,
		alpha: 0.8
	});
	// Add title text
	var title = new Text2('Enemypedia', {
		size: 100,
		fill: 0xFFFFFF
	});
	title.anchor.set(0.5, 0.5);
	title.y = -500; // Position relative to popup center
	enemypediaPopup.addChild(title);
	// Add a close button
	var closeButton = createCloseButton();
	closeButton.x = 750; // Position relative to popup center
	closeButton.y = -500;
	enemypediaPopup.addChild(closeButton);
	// Container for the enemy details
	enemyListContainer = new Container();
	enemyListContainer.y = -100; // Centered position for detailed view
	enemypediaPopup.addChild(enemyListContainer);
	displayEnemyStats();
}
function hideEnemypedia() {
	if (enemypediaPopup) {
		enemypediaPopup.destroy();
		enemypediaPopup = null;
	}
	isUpgradePopupActive = false; // Unpause the game
}
function createCloseButton() {
	var buttonContainer = new Container();
	var buttonBg = buttonContainer.attachAsset('bastionLine', {
		width: 150,
		height: 80,
		color: 0xCC0000,
		// Red color for close
		anchorX: 0.5,
		anchorY: 0.5
	});
	var buttonText = new Text2('X', {
		size: 60,
		fill: 0xFFFFFF
	});
	buttonText.anchor.set(0.5, 0.5);
	buttonContainer.addChild(buttonText);
	buttonContainer.interactive = true;
	buttonContainer.down = function () {
		hideEnemypedia();
	};
	return buttonContainer;
}
function displayEnemyStats() {
	// Dummy data representing enemy types and their stats
	var enemyData = [{
		type: 'swordsman',
		assetId: 'enemy',
		description: 'Basic melee unit that has very low HP.',
		baseHealth: 1,
		baseSpeed: 3,
		dodgeChance: 0
	}, {
		type: 'knight',
		assetId: 'knight',
		description: 'A threat for the first few waves cause of its high health, but is slow.',
		baseHealth: 5,
		baseSpeed: 3 * 0.9,
		dodgeChance: 0
	}, {
		type: 'thief',
		assetId: 'thief',
		description: 'Fast, low health unit with a dodge chance; likes gravy.',
		baseHealth: 1,
		baseSpeed: 3 * 1.2,
		dodgeChance: 0.1
	}, {
		type: 'boss',
		assetId: 'boss',
		description: 'a boss that spawns randomly when youre in trobule.',
		baseHealth: 5,
		// Base health before scaling
		baseSpeed: 3 * 0.7,
		dodgeChance: 0
	}, {
		type: 'shield',
		assetId: 'shield_enemy',
		description: 'Slow unit that has high HP',
		baseHealth: 20,
		baseSpeed: 3 * 0.5,
		dodgeChance: 0
	}, {
		type: 'wizard',
		assetId: 'wizard_enemy',
		description: 'kinda tricky cause it teleports and has moderate speed.',
		baseHealth: 2,
		baseSpeed: 3 * 0.7,
		dodgeChance: 0
	}, {
		type: 'spearman',
		assetId: 'spearman',
		description: 'Standard, annoying green unit that spawns from Elephants most of the time.',
		baseHealth: 2,
		baseSpeed: 3 * 1.0,
		dodgeChance: 0
	}, {
		type: 'war_elephant',
		assetId: 'war_elephant',
		description: 'Extremely high health elephant, spawns spearmen on death',
		baseHealth: 500,
		baseSpeed: 3 * 0.3,
		dodgeChance: 0
	}, {
		type: 'elite_knight',
		assetId: 'elite_knight_asset',
		description: 'High health knight variant that is loyal to the king',
		baseHealth: 45,
		baseSpeed: 3 * 0.85,
		dodgeChance: 0
	}, {
		type: 'elite_shield',
		assetId: 'elite_shield_asset',
		description: 'Even higher health shield variant that is loyal to the king',
		baseHealth: 200,
		baseSpeed: 3 * 0.4,
		dodgeChance: 0
	}, {
		type: 'shaman',
		assetId: 'shaman_enemy',
		description: 'Reduces your ammo when he feels like it',
		baseHealth: 2,
		baseSpeed: 3 * 0.8,
		dodgeChance: 0
	}, {
		type: 'hot_air_balloon',
		assetId: 'hot_air_balloon_asset',
		description: 'Very low health. Spawns random non-green enemies on death.',
		baseHealth: 1,
		baseSpeed: 3 * 0.2,
		dodgeChance: 0
	}, {
		type: 'dark_bowman',
		assetId: 'dark_bowman_asset',
		description: 'Immune to arrows and cannonballs. Worst enemy of blue archers',
		baseHealth: 5,
		baseSpeed: 3 * 1.1,
		dodgeChance: 0
	}, {
		type: 'jester',
		assetId: 'jester_asset',
		description: 'High chance to dodge or reflect non-cannonball projectiles...YOU WILL LAUGH AT ALL OF HIS TRICKS',
		baseHealth: 2,
		baseSpeed: 3 * 1.1,
		dodgeChance: 0.3,
		// 30% dodge
		reflectChance: 0.2 // 20% reflect chance for non-cannonballs
	}, {
		type: 'dark_war_elephant',
		assetId: 'dark_war_elephant_asset',
		description: 'Immune to arrows. variant of green elephant, spawns Dark Bowmen on death.',
		baseHealth: 450,
		// Slightly less than green elephant
		baseSpeed: 3 * 0.3,
		// Same slow speed
		dodgeChance: 0
	}, {
		type: 'dark_spearman',
		assetId: 'dark_spearman_asset',
		description: 'A faster and more resistant spearman variant that came straight from rome. Immune to arrows and cannonballs',
		baseHealth: 15,
		// Base health
		baseSpeed: 3 * 1.2,
		// Faster than spearman
		dodgeChance: 0,
		tag: 'Black' // Immune to arrows and cannonballs
	}, {
		type: 'dragon',
		assetId: 'dragon_asset',
		description: 'A fearsome dragon with great HP and a high chance to dodge attacks. Cant be slowed down',
		baseHealth: 250,
		// Great HP
		baseSpeed: 3 * 0.9,
		// Moderately fast
		dodgeChance: 0.40,
		// High dodge chance (40%)
		tag: 'Dragon' // Special tag if needed for other mechanics, for now dodge is key
	}, {
		type: 'flag_bearer',
		assetId: 'flag_bearer_asset',
		description: 'Green-tagged enemy with an aura that makes nearby enemies move 50% faster',
		baseHealth: 5,
		baseSpeed: 3 * 0.8,
		dodgeChance: 0,
		tag: 'Green'
	}, {
		type: 'baby_dragon',
		assetId: 'baby_dragon_asset',
		description: 'Small dragon with less health but enters rage mode (double speed) when no other dragons are present',
		baseHealth: 50,
		baseSpeed: 3 * 1.1,
		dodgeChance: 0.25,
		tag: 'Dragon'
	}];
	// Clear any existing content in the list container
	while (enemyListContainer.children.length > 0) {
		enemyListContainer.removeChildAt(0);
	}
	// Current page tracking
	var currentEnemy = 0;
	var totalEnemies = enemyData.length;
	// Create enemy details display
	function displayEnemyDetails(index) {
		// Clear any existing content in the list container
		while (enemyListContainer.children.length > 0) {
			enemyListContainer.removeChildAt(0);
		}
		var enemyInfo = enemyData[index];
		// Enemy display container
		var enemyDisplay = new Container();
		enemyDisplay.y = 0;
		enemyListContainer.addChild(enemyDisplay);
		// Add enemy graphic (larger for individual view)
		var enemyGraphic = enemyDisplay.attachAsset(enemyInfo.assetId, {
			anchorX: 0.5,
			anchorY: 0.5,
			scaleX: 0.8,
			scaleY: 0.8,
			x: -400,
			y: 50
		});
		// Add enemy name (larger font)
		var nameText = new Text2(enemyInfo.type.replace(/_/g, ' ').toUpperCase(), {
			size: 60,
			fill: 0xFFFFFF
		});
		nameText.anchor.set(0.5, 0);
		nameText.x = 0;
		nameText.y = -300;
		enemyDisplay.addChild(nameText);
		// Add description
		var descText = new Text2('Description: ' + enemyInfo.description, {
			size: 40,
			fill: 0xCCCCCC,
			wordWrap: true,
			wordWrapWidth: 1000
		});
		descText.anchor.set(0, 0);
		descText.x = -100;
		descText.y = -200;
		enemyDisplay.addChild(descText);
		// Add stats with improved layout
		var healthText = new Text2('Health: ' + enemyInfo.baseHealth, {
			size: 40,
			fill: 0x88FF88
		});
		healthText.anchor.set(0, 0);
		healthText.x = -100;
		healthText.y = -100;
		enemyDisplay.addChild(healthText);
		var speedText = new Text2('Speed: ' + enemyInfo.baseSpeed.toFixed(1), {
			size: 40,
			fill: 0x88CCFF
		});
		speedText.anchor.set(0, 0);
		speedText.x = -100;
		speedText.y = -40;
		enemyDisplay.addChild(speedText);
		var dodgeText = new Text2('Dodge Chance: ' + (enemyInfo.dodgeChance * 100).toFixed(0) + '%', {
			size: 40,
			fill: 0xFFCC88
		});
		dodgeText.anchor.set(0, 0);
		dodgeText.x = -100;
		dodgeText.y = 20;
		enemyDisplay.addChild(dodgeText);
		// Add reflect chance
		var reflectText = new Text2('Reflect Chance: ' + (enemyInfo.reflectChance * 100 || 0).toFixed(0) + '%', {
			size: 40,
			fill: 0xFFCCEE
		});
		reflectText.anchor.set(0, 0);
		reflectText.x = -100;
		reflectText.y = 80;
		enemyDisplay.addChild(reflectText);
		// Add unlock score
		var unlockScore = 0; // Default for swordsman
		if (enemyInfo.type === 'spearman') {
			unlockScore = 10;
		} else if (enemyInfo.type === 'thief') {
			unlockScore = 15;
		} else if (enemyInfo.type === 'knight') {
			unlockScore = 23;
		} else if (enemyInfo.type === 'wizard') {
			unlockScore = 25;
		} else if (enemyInfo.type === 'shield') {
			unlockScore = 30;
		} else if (enemyInfo.type === 'shaman') {
			unlockScore = 35;
		} else if (enemyInfo.type === 'dark_spearman') {
			unlockScore = 55;
		} // Dark Spearman unlock score
		else if (enemyInfo.type === 'dark_bowman') {
			unlockScore = 55;
		} // Note: Same as Dark Spearman, might need adjustment if only one is desired at 55. Keeping as per request.
		else if (enemyInfo.type === 'jester') {
			unlockScore = 69;
		} else if (enemyInfo.type === 'dragon') {
			unlockScore = 134;
		} // Dragon unlock score
		else if (enemyInfo.type === 'flag_bearer') {
			unlockScore = 27;
		} // Flag Bearer unlock score
		else if (enemyInfo.type === 'baby_dragon') {
			unlockScore = 125;
		} // Baby Dragon unlock score (same as war elephant)
		else if (enemyInfo.type === 'elite_knight') {
			unlockScore = 100;
		} else if (enemyInfo.type === 'elite_shield') {
			unlockScore = 112;
		} else if (enemyInfo.type === 'war_elephant') {
			unlockScore = 125;
		} else if (enemyInfo.type === 'dark_war_elephant') {
			unlockScore = 145;
		} // Dark war elephant starts appearing at score 145
		else if (enemyInfo.type === 'hot_air_balloon') {
			unlockScore = 154;
		}
		var unlockText = new Text2('Unlocks at Score: ' + unlockScore, {
			size: 40,
			fill: 0xFF88FF
		});
		unlockText.anchor.set(0, 0);
		unlockText.x = -100;
		unlockText.y = 140; // Adjusted Y position
		enemyDisplay.addChild(unlockText);
		// Status display (current enemy / total)
		var statusText = new Text2('Enemy ' + (index + 1) + ' of ' + totalEnemies, {
			size: 30,
			fill: 0xAAAAAA
		});
		statusText.anchor.set(0.5, 0);
		statusText.x = 0;
		statusText.y = 150;
		enemyDisplay.addChild(statusText);
		// Navigation buttons container
		var navButtons = new Container();
		navButtons.y = 250;
		enemyDisplay.addChild(navButtons);
		// Previous button
		var prevButton = createNavButton('← Previous', -250, function () {
			currentEnemy = (currentEnemy - 1 + totalEnemies) % totalEnemies;
			displayEnemyDetails(currentEnemy);
		});
		navButtons.addChild(prevButton);
		// Next button
		var nextButton = createNavButton('Next →', 250, function () {
			currentEnemy = (currentEnemy + 1) % totalEnemies;
			displayEnemyDetails(currentEnemy);
		});
		navButtons.addChild(nextButton);
	}
	// Create navigation button
	function createNavButton(label, xPos, callback) {
		var button = new Container();
		button.x = xPos;
		var buttonBg = button.attachAsset('bastionLine', {
			width: 250,
			height: 80,
			color: 0x555555,
			anchorX: 0.5,
			anchorY: 0.5
		});
		var buttonText = new Text2(label, {
			size: 40,
			fill: 0xFFFFFF
		});
		buttonText.anchor.set(0.5, 0.5);
		button.addChild(buttonText);
		button.interactive = true;
		button.down = callback;
		return button;
	}
	// Initial display
	displayEnemyDetails(currentEnemy);
}
enemypediaButton = new Container();
// Position the button (e.g., bottom right of GUI)
enemypediaButton.x = GAME_WIDTH - 200; // Example X
enemypediaButton.y = GAME_HEIGHT - 200; // Example Y
// Add button background
var buttonBg = enemypediaButton.attachAsset('bastionLine', {
	// Reusing asset for shape
	width: 300,
	height: 100,
	color: 0x444444,
	// Grey color
	anchorX: 0.5,
	anchorY: 0.5
});
// Add button text
var buttonText = new Text2('Enemypedia', {
	size: 40,
	fill: 0xFFFFFF
});
buttonText.anchor.set(0.5, 0.5);
enemypediaButton.addChild(buttonText);
// Make button interactive
enemypediaButton.interactive = true;
enemypediaButton.down = function () {
	showEnemypedia();
};
// Add the button to the game scene (or GUI if needed)
game.addChild(enemypediaButton);
// --- Relic Shop ---
var relicShopPopup = null;
var relicListContainer = null;
var goldText; // Text display for gold
function showRelicShop() {
	isUpgradePopupActive = true; // Pause the game
	relicShopPopup = new Container();
	relicShopPopup.x = GAME_WIDTH / 2;
	relicShopPopup.y = GAME_HEIGHT / 2;
	game.addChild(relicShopPopup);
	var bg = relicShopPopup.attachAsset('pedia_screen_bg', {
		width: 1600,
		height: 2000,
		anchorX: 0.5,
		anchorY: 0.5,
		alpha: 0.9
	});
	var title = new Text2('Relic Shop', {
		size: 100,
		fill: 0xFFFFFF
	});
	title.anchor.set(0.5, 0.5);
	title.y = -900;
	relicShopPopup.addChild(title);
	var closeButton = createRelicShopCloseButton();
	closeButton.x = 750;
	closeButton.y = -900;
	relicShopPopup.addChild(closeButton);
	// Gold display
	goldText = new Text2('Gold: ' + playerGold, {
		size: 50,
		fill: 0xFFD700
	});
	goldText.anchor.set(0.5, 0.5);
	goldText.y = -800;
	relicShopPopup.addChild(goldText);
	relicListContainer = new Container();
	relicListContainer.y = -200;
	relicShopPopup.addChild(relicListContainer);
	displayRelicDetails();
}
function hideRelicShop() {
	if (relicShopPopup) {
		relicShopPopup.destroy();
		relicShopPopup = null;
	}
	isUpgradePopupActive = false; // Unpause the game
}
function createRelicShopCloseButton() {
	var buttonContainer = new Container();
	var buttonBg = buttonContainer.attachAsset('pedia_button_bg', {
		width: 150,
		height: 80,
		color: 0xCC0000,
		anchorX: 0.5,
		anchorY: 0.5
	});
	var buttonText = new Text2('X', {
		size: 60,
		fill: 0xFFFFFF
	});
	buttonText.anchor.set(0.5, 0.5);
	buttonContainer.addChild(buttonText);
	buttonContainer.interactive = true;
	buttonContainer.down = function () {
		hideRelicShop();
	};
	return buttonContainer;
}
function displayRelicDetails() {
	while (relicListContainer.children.length > 0) {
		relicListContainer.removeChildAt(0);
	}
	var relicsData = [{
		id: 'damage',
		name: 'Damage Relic',
		description: 'Increase projectile, swordsman, and poison damage.',
		effect: '+1 damage per level'
	}, {
		id: 'slowdown',
		name: 'Slowdown Relic',
		description: 'All enemies are slower.',
		effect: '+2% slowdown per level'
	}, {
		id: 'green',
		name: 'Green Relic',
		description: 'Green enemies are slower and take more damage.',
		effect: '+2% slow & +2% damage per level'
	}, {
		id: 'dark',
		name: 'Dark Relic',
		description: 'Dark enemies can be hit by arrows/cannonballs and take more damage from them.',
		effect: '+5% damage per level'
	}, {
		id: 'dragon',
		name: 'Dragon Relic',
		description: 'Projectiles stun dragons.',
		effect: '+0.05 seconds stun per level'
	}, {
		id: 'reload',
		name: 'Reload Relic',
		description: 'Reload faster! Essential for rapid-fire gameplay.',
		effect: '-0.5 seconds reload time per level'
	}, {
		id: 'ammo',
		name: 'Ammo Relic',
		description: 'Regenerate ammo over time without reloading.',
		effect: '+1 ammo regenerated every 5 seconds per level'
	}, {
		id: 'swordsman',
		name: 'Swordsman Relic',
		description: 'Start each battle with a permanent swordsman ally.',
		effect: 'Unlocks permanent swordsman, +2 damage per upgrade'
	}];
	// Current page tracking
	var currentRelic = 0;
	var totalRelics = relicsData.length;
	// Create relic details display
	function displayRelicItem(index) {
		// Clear any existing content in the list container
		while (relicListContainer.children.length > 0) {
			relicListContainer.removeChildAt(0);
		}
		var relic = relicsData[index];
		var relicInfo = playerRelics[relic.id];
		// Relic display container
		var relicDisplay = new Container();
		relicDisplay.y = 0;
		relicListContainer.addChild(relicDisplay);
		// Background
		var bg = relicDisplay.attachAsset('pedia_button_bg', {
			width: 1400,
			height: 400,
			color: 0x333355,
			anchorX: 0.5,
			anchorY: 0.5
		});
		// Relic Name
		var nameText = new Text2(relic.name + ' (Level ' + relicInfo.level + '/' + RELIC_MAX_LEVEL + ')', {
			size: 70,
			fill: 0xFFFFFF
		});
		nameText.anchor.set(0.5, 0);
		nameText.x = 0;
		nameText.y = -300;
		relicDisplay.addChild(nameText);
		// Relic Description
		var descText = new Text2(relic.description, {
			size: 45,
			fill: 0xCCCCCC,
			wordWrap: true,
			wordWrapWidth: 1200
		});
		descText.anchor.set(0.5, 0);
		descText.x = 0;
		descText.y = -200;
		relicDisplay.addChild(descText);
		// Relic Effect
		var effectText = new Text2('Effect: ' + relic.effect, {
			size: 40,
			fill: 0x88FF88,
			wordWrap: true,
			wordWrapWidth: 1200
		});
		effectText.anchor.set(0.5, 0);
		effectText.x = 0;
		effectText.y = -100;
		relicDisplay.addChild(effectText);
		// Buttons container
		var buttonsContainer = new Container();
		buttonsContainer.y = 0;
		relicDisplay.addChild(buttonsContainer);
		// Buy/Upgrade Button
		var buyButton = new Container();
		buyButton.x = -200;
		var buyBtnBgColor = relicInfo.level < RELIC_MAX_LEVEL ? 0x00CC00 : 0x666666;
		var buyBtnTextColor = relicInfo.level < RELIC_MAX_LEVEL ? 0xFFFFFF : 0xAAAAAA;
		var buyBtnBg = buyButton.attachAsset('pedia_nav_button_bg', {
			width: 200,
			height: 80,
			color: buyBtnBgColor,
			anchorX: 0.5,
			anchorY: 0.5
		});
		var buyBtnText = new Text2(relicInfo.level < RELIC_MAX_LEVEL ? 'Buy (5)' : 'MAX', {
			size: 40,
			fill: buyBtnTextColor
		});
		buyBtnText.anchor.set(0.5, 0.5);
		buyButton.addChild(buyBtnText);
		buyButton.interactive = relicInfo.level < RELIC_MAX_LEVEL && playerGold >= RELIC_COST_PER_LEVEL;
		if (buyButton.interactive) {
			buyButton.down = function (relicId) {
				return function () {
					if (playerGold >= RELIC_COST_PER_LEVEL && playerRelics[relicId].level < RELIC_MAX_LEVEL) {
						playerGold -= RELIC_COST_PER_LEVEL;
						playerRelics[relicId].level++;
						storage.playerGold = playerGold;
						// Reset ammo relic timer if ammo relic was upgraded
						if (relicId === 'ammo') {
							ammoRelicTimer = 0; // Reset timer when upgrading
						}
						// Save relics to storage using safe serialization
						try {
							var relicsData = {};
							relicsData.damage_level = playerRelics.damage.level;
							relicsData.damage_enabled = playerRelics.damage.enabled;
							relicsData.slowdown_level = playerRelics.slowdown.level;
							relicsData.slowdown_enabled = playerRelics.slowdown.enabled;
							relicsData.green_level = playerRelics.green.level;
							relicsData.green_enabled = playerRelics.green.enabled;
							relicsData.dark_level = playerRelics.dark.level;
							relicsData.dark_enabled = playerRelics.dark.enabled;
							relicsData.dragon_level = playerRelics.dragon.level;
							relicsData.dragon_enabled = playerRelics.dragon.enabled;
							relicsData.reload_level = playerRelics.reload.level;
							relicsData.reload_enabled = playerRelics.reload.enabled;
							relicsData.ammo_level = playerRelics.ammo.level;
							relicsData.ammo_enabled = playerRelics.ammo.enabled;
							relicsData.swordsman_level = playerRelics.swordsman.level;
							relicsData.swordsman_enabled = playerRelics.swordsman.enabled;
							storage.playerRelicsData = relicsData;
						} catch (e) {
							console.log("Error saving relics:", e);
						}
						goldText.setText('Gold: ' + playerGold);
						displayRelicItem(currentRelic); // Refresh the current relic display
					}
				};
			}(relic.id);
		}
		buttonsContainer.addChild(buyButton);
		// On/Off Button
		var toggleButton = new Container();
		toggleButton.x = 200;
		var toggleBtnBgColor = relicInfo.enabled ? 0x008800 : 0x880000;
		var toggleBtnBg = toggleButton.attachAsset('pedia_nav_button_bg', {
			width: 150,
			height: 80,
			color: toggleBtnBgColor,
			anchorX: 0.5,
			anchorY: 0.5
		});
		var toggleBtnText = new Text2(relicInfo.enabled ? 'ON' : 'OFF', {
			size: 40,
			fill: 0xFFFFFF
		});
		toggleBtnText.anchor.set(0.5, 0.5);
		toggleButton.addChild(toggleBtnText);
		toggleButton.interactive = relicInfo.level > 0; // Only interactive if relic is owned
		if (toggleButton.interactive) {
			toggleButton.down = function (relicId) {
				return function () {
					playerRelics[relicId].enabled = !playerRelics[relicId].enabled;
					// Reset ammo relic timer if ammo relic was toggled
					if (relicId === 'ammo') {
						ammoRelicTimer = 0; // Reset timer when toggling
					}
					// Save relics to storage using safe serialization
					try {
						var relicsData = {};
						relicsData.damage_level = playerRelics.damage.level;
						relicsData.damage_enabled = playerRelics.damage.enabled;
						relicsData.slowdown_level = playerRelics.slowdown.level;
						relicsData.slowdown_enabled = playerRelics.slowdown.enabled;
						relicsData.green_level = playerRelics.green.level;
						relicsData.green_enabled = playerRelics.green.enabled;
						relicsData.dark_level = playerRelics.dark.level;
						relicsData.dark_enabled = playerRelics.dark.enabled;
						relicsData.dragon_level = playerRelics.dragon.level;
						relicsData.dragon_enabled = playerRelics.dragon.enabled;
						relicsData.reload_level = playerRelics.reload.level;
						relicsData.reload_enabled = playerRelics.reload.enabled;
						relicsData.ammo_level = playerRelics.ammo.level;
						relicsData.ammo_enabled = playerRelics.ammo.enabled;
						relicsData.swordsman_level = playerRelics.swordsman.level;
						relicsData.swordsman_enabled = playerRelics.swordsman.enabled;
						storage.playerRelicsData = relicsData;
					} catch (e) {
						console.log("Error saving relics:", e);
					}
					displayRelicItem(currentRelic); // Refresh the current relic display
				};
			}(relic.id);
		} else {
			toggleBtnBg.tint = 0x666666; // Grey out if not owned
		}
		buttonsContainer.addChild(toggleButton);
		// Status display (current relic / total)
		var statusText = new Text2('Relic ' + (index + 1) + ' of ' + totalRelics, {
			size: 35,
			fill: 0xAAAAAA
		});
		statusText.anchor.set(0.5, 0);
		statusText.x = 0;
		statusText.y = 150;
		relicDisplay.addChild(statusText);
		// Navigation buttons container
		var navButtons = new Container();
		navButtons.y = 250;
		relicDisplay.addChild(navButtons);
		// Previous button
		var prevButton = createRelicNavButton('← Previous', -250, function () {
			currentRelic = (currentRelic - 1 + totalRelics) % totalRelics;
			displayRelicItem(currentRelic);
		});
		navButtons.addChild(prevButton);
		// Next button
		var nextButton = createRelicNavButton('Next →', 250, function () {
			currentRelic = (currentRelic + 1) % totalRelics;
			displayRelicItem(currentRelic);
		});
		navButtons.addChild(nextButton);
	}
	function createRelicNavButton(label, xPos, callback) {
		var button = new Container();
		button.x = xPos;
		var buttonBg = button.attachAsset('pedia_nav_button_bg', {
			width: 250,
			height: 80,
			anchorX: 0.5,
			anchorY: 0.5
		});
		var buttonText = new Text2(label, {
			size: 40,
			fill: 0xFFFFFF
		});
		buttonText.anchor.set(0.5, 0.5);
		button.addChild(buttonText);
		button.interactive = true;
		button.down = callback;
		return button;
	}
	// Initial display
	displayRelicItem(currentRelic);
}
// --- Input Event Handlers ---
// Handles touch/mouse press down event on the game area.
game.down = function (x, y, obj) {
	// Record the starting position of the drag in game coordinates.
	var gamePos = game.toLocal({
		x: x,
		y: y
	});
	dragStartX = gamePos.x;
	dragStartY = gamePos.y;
	// Potential enhancement: Show an aiming indicator originating from FIRING_POS_X, FIRING_POS_Y towards the drag point.
};
// Handles touch/mouse move event while dragging on the game area.
game.move = function (x, y, obj) {
	// Only process if a drag is currently active.
	if (dragStartX !== null) {
		var gamePos = game.toLocal({
			x: x,
			y: y
		});
		// Potential enhancement: Update the aiming indicator based on the current drag position (gamePos).
	}
};
// Handles touch/mouse release event on the game area.
game.up = function (x, y, obj) {
	// Only process if a drag was active.
	if (dragStartX !== null && cooldownTimer <= 0) {
		// Only allow firing if not on cooldown.
		var gamePos = game.toLocal({
			x: x,
			y: y
		});
		var dragEndX = gamePos.x;
		var dragEndY = gamePos.y;
		// Calculate the difference between the firing position and the release point to determine direction.
		// A longer drag could potentially mean more power, but we'll keep it simple: direction only.
		var dx = dragEndX - FIRING_POS_X;
		var dy = dragEndY - FIRING_POS_Y;
		// Avoid division by zero or zero vector if start and end points are the same.
		if (dx === 0 && dy === 0) {
			// Optionally handle this case, e.g., fire straight up or do nothing.
			// Let's fire straight up if drag distance is negligible.
			dy = -1;
		}
		// Calculate the angle using atan2. Note the order (dx, dy) and the negation of dy
		// because the Y-axis is inverted in screen coordinates (positive Y is down).
		var angle = Math.atan2(dx, -dy);
		// Create a new arrow instance with the calculated angle.
		var newArrow = new Arrow(angle);
		newArrow.x = FIRING_POS_X;
		newArrow.y = FIRING_POS_Y;
		// Initialize last position for state tracking (e.g., off-screen detection)
		newArrow.lastY = newArrow.y;
		newArrow.lastX = newArrow.x;
		// Add the arrow to the game scene and the tracking array.
		game.addChild(newArrow);
		arrows.push(newArrow);
		if (multiShotEnabled) {
			// Fire a second arrow with a slight angle offset
			var angle2 = angle + Math.PI / 12; // Offset by 15 degrees
			var newArrow2 = new Arrow(angle2);
			newArrow2.x = FIRING_POS_X;
			newArrow2.y = FIRING_POS_Y;
			newArrow2.lastY = newArrow2.y;
			newArrow2.lastX = newArrow2.x;
			game.addChild(newArrow2);
			arrows.push(newArrow2);
			// Fire a third arrow with the opposite angle offset
			var angle3 = angle - Math.PI / 12; // Offset by -15 degrees
			var newArrow3 = new Arrow(angle3);
			newArrow3.x = FIRING_POS_X;
			newArrow3.y = FIRING_POS_Y;
			newArrow3.lastY = newArrow3.y;
			newArrow3.lastX = newArrow3.x;
			game.addChild(newArrow3);
			arrows.push(newArrow3);
		}
		LK.getSound('shoot').play(); // Play shooting sound.
		arrowsFired++; // Increment arrow count.
		ammoTxt.setText('Ammo: ' + (maxArrowsBeforeCooldown - arrowsFired)); // Update ammo display.
		// Check if cooldown needs to start based on Quiver upgrade
		if (arrowsFired >= maxArrowsBeforeCooldown) {
			var effectiveCooldownDuration = cooldownDuration;
			// Apply reload relic bonus if enabled
			if (playerRelics.reload.enabled) {
				effectiveCooldownDuration = Math.max(30, cooldownDuration - playerRelics.reload.level * 30); // 0.5 seconds faster per level, min 0.5s
			}
			cooldownTimer = effectiveCooldownDuration; // Start cooldown (duration affected by Faster Reload upgrade and reload relic)
			arrowsFired = 0; // Reset arrow count.
			ammoTxt.setText('Ammo: ' + (maxArrowsBeforeCooldown - arrowsFired)); // Update ammo display.
			LK.getSound('Reload').play(); // Play reload sound.
		}
		// Reset drag state.
		dragStartX = null;
		dragStartY = null;
		// Potential enhancement: Hide the aiming indicator.
	}
};
// --- Main Game Update Loop ---
// This function is called automatically by the LK engine on every frame (tick).
game.update = function () {
	// --- Upgrade System Check ---
	var currentScore = LK.getScore();
	// Check if score reached a multiple of 10 and is higher than the last upgrade score
	if (!isUpgradePopupActive && currentScore > 0 && currentScore % 10 === 0 && currentScore !== lastUpgradeScore) {
		lastUpgradeScore = currentScore; // Mark this score level as having triggered an upgrade offer
		showUpgradePopup(); // Show the upgrade selection screen
	}
	// --- Pause Game Logic if Upgrade Popup is Active ---
	if (isUpgradePopupActive) {
		// Potential: Update UI animations if any
		return; // Skip the rest of the game update loop
	}
	// --- Resume Game Logic ---
	if (isUpgradePopupActive) {
		return; // Skip enemy movement and spawning if upgrade popup is active
	}
	// Handle ammo relic regeneration
	if (playerRelics.ammo.enabled && playerRelics.ammo.level > 0) {
		ammoRelicTimer++;
		// Give ammo every 5 seconds (300 ticks)
		if (ammoRelicTimer >= 300) {
			ammoRelicTimer = 0;
			// Only regenerate if not at max ammo and not reloading
			if (arrowsFired > 0 && cooldownTimer <= 0) {
				// Give ammo based on relic level (1 per level)
				var ammoToRegenerate = playerRelics.ammo.level;
				arrowsFired = Math.max(0, arrowsFired - ammoToRegenerate);
				ammoTxt.setText('Ammo: ' + (maxArrowsBeforeCooldown - arrowsFired));
			}
		}
	}
	// Decrease cooldown timer if active.
	if (cooldownTimer > 0) {
		cooldownTimer--;
		ammoTxt.setText('Reloading...'); // Show reloading status
	} else if (ammoTxt.text !== 'Ammo: ' + (maxArrowsBeforeCooldown - arrowsFired)) {
		// Ensure ammo display is correct if not reloading
		ammoTxt.setText('Ammo: ' + (maxArrowsBeforeCooldown - arrowsFired));
	}
	// 1. Update and check Arrows
	for (var i = arrows.length - 1; i >= 0; i--) {
		var arrow = arrows[i];
		// Note: LK engine calls arrow.update() automatically as it's added to the game stage.
		// Initialize last position if it hasn't been set yet (first frame).
		if (arrow.lastY === undefined) {
			arrow.lastY = arrow.y;
		}
		if (arrow.lastX === undefined) {
			arrow.lastX = arrow.x;
		}
		// Check for collisions between the current arrow and all enemies.
		var hitEnemy = false;
		for (var j = enemies.length - 1; j >= 0; j--) {
			var enemy = enemies[j];
			// Use the intersects method for collision detection.
			if (arrow.intersects(enemy)) {
				// Collision detected!
				LK.getSound('hit').play(); // Play hit sound.
				// Calculate damage, applying Green Killer bonus if applicable
				var damageToDeal = arrow.damage;
				if (greenKillerEnabled && enemy.tag === 'Green') {
					damageToDeal *= 1.5; // Apply 50% damage bonus
				}
				// Apply damage to the enemy and check if it was defeated
				var enemyDefeated = enemy.takeDamage(damageToDeal, arrow); // Pass the arrow object as source
				// Check if the arrow was reflected (takeDamage returns false and arrow is destroyed)
				if (!enemyDefeated && !arrow.parent) {
					// Arrow was reflected, remove it from the array and stop processing
					arrows.splice(i, 1);
					hitEnemy = true; // Mark that this arrow is done
					break; // Stop checking this arrow against other enemies as it's destroyed
				}
				if (enemyDefeated) {
					LK.setScore(LK.getScore() + 1); // Increment score.
					scoreTxt.setText(LK.getScore()); // Update score display.
					// Destroy the enemy
					enemy.destroy();
					enemies.splice(j, 1); // Remove enemy from array.
				}
				// Handle arrow piercing
				arrow.pierceLeft--; // Decrease remaining pierces
				if (arrow.pierceLeft <= 0) {
					// Arrow has no pierces left, destroy it
					arrow.destroy();
					arrows.splice(i, 1); // Remove arrow from array.
					hitEnemy = true; // Mark that this arrow is done
					break; // Stop checking this arrow against other enemies as it's destroyed
				} else {
					// Arrow pierced this enemy and can continue
					// We don't set hitEnemy = true here because the arrow continues
					// We don't break because it might hit another enemy in the same frame further along its path
					// Apply Green Slowdown if applicable and arrow is still piercing
					if (!enemyDefeated && greenSlowdownEnabled && enemy.tag === 'Green' && enemy.slowTimer <= 0) {
						enemy.slowTimer = 10 * 60;
						enemy.currentSlowAmount = 0.9;
					}
				}
			}
		}
		// If the arrow hit an enemy, it was destroyed, so skip to the next arrow.
		if (hitEnemy) {
			continue;
		}
		// Check if the arrow has gone off-screen (top, left, or right).
		// Use transition detection: check if it was on screen last frame and is off screen now.
		var wasOnScreen = arrow.lastY > -arrow.height / 2 && arrow.lastX > -arrow.width / 2 && arrow.lastX < GAME_WIDTH + arrow.width / 2;
		var isOffScreen = arrow.y < -arrow.height / 2 ||
		// Off top edge
		arrow.x < -arrow.width / 2 ||
		// Off left edge
		arrow.x > GAME_WIDTH + arrow.width / 2; // Off right edge
		if (wasOnScreen && isOffScreen) {
			// Arrow is off-screen, destroy it and remove from the array.
			arrow.destroy();
			arrows.splice(i, 1);
		} else if (!isOffScreen) {
			// Update last known position only if the arrow is still potentially on screen
			arrow.lastY = arrow.y;
			arrow.lastX = arrow.x;
		}
	}
	// 2. Update and check Cannonballs
	for (var cb = cannonballs.length - 1; cb >= 0; cb--) {
		var cannonball = cannonballs[cb];
		// Note: LK engine calls cannonball.update() automatically.
		// Initialize last position if it hasn't been set yet (first frame).
		if (cannonball.lastY === undefined) {
			cannonball.lastY = cannonball.y;
		}
		if (cannonball.lastX === undefined) {
			cannonball.lastX = cannonball.x;
		}
		// Check for collisions between the current cannonball and all enemies.
		var hitEnemy = false;
		for (var j = enemies.length - 1; j >= 0; j--) {
			var enemy = enemies[j];
			// Use the intersects method for collision detection.
			if (cannonball.intersects(enemy)) {
				// Collision detected!
				LK.getSound('hit').play(); // Play hit sound.
				// Apply damage to the enemy and check if it was defeated
				var damageToApply = cannonball.damage;
				// Apply dragon slayer damage multiplier if applicable
				if (cannonball.dragonDamageMultiplier && enemy.tag === 'Dragon') {
					damageToApply *= cannonball.dragonDamageMultiplier;
				}
				var enemyDefeated = enemy.takeDamage(damageToApply, cannonball); // Pass cannonball as source
				// Check if the cannonball had no effect (e.g. Dark War Elephant immunity) and is still in game
				if (!enemyDefeated && cannonball.parent) {
					// Cannonball had no effect, but wasn't destroyed by a normal hit.
					// It might have been immune. If so, we still destroy the cannonball.
					cannonball.destroy();
					cannonballs.splice(cb, 1);
					hitEnemy = true; // Mark that this cannonball is done
					break; // Stop checking this cannonball against other enemies as it's destroyed
				}
				if (enemyDefeated) {
					LK.setScore(LK.getScore() + 1); // Increment score.
					scoreTxt.setText(LK.getScore()); // Update score display.
					// Destroy the enemy
					enemy.destroy();
					enemies.splice(j, 1); // Remove enemy from array.
				}
				// Cannonballs are destroyed on hit
				cannonball.destroy();
				// Apply Green Slowdown if applicable before destroying cannonball
				if (greenSlowdownEnabled && enemy.tag === 'Green' && enemy.slowTimer <= 0) {
					enemy.slowTimer = 10 * 60;
					enemy.currentSlowAmount = 0.9;
				}
				cannonball.destroy();
				cannonballs.splice(cb, 1); // Remove cannonball from array.
				hitEnemy = true; // Mark that this cannonball is done
				break; // Stop checking this cannonball against other enemies as it's destroyed
			}
		}
		// If the cannonball hit an enemy, it was destroyed, so skip to the next cannonball.
		if (hitEnemy) {
			continue;
		}
		// Check if the cannonball has gone off-screen.
		var wasOnScreen = cannonball.lastY > -cannonball.height / 2 && cannonball.lastX > -cannonball.width / 2 && cannonball.lastX < GAME_WIDTH + cannonball.width / 2;
		var isOffScreen = cannonball.y < -cannonball.height / 2 ||
		// Off top edge
		cannonball.x < -cannonball.width / 2 ||
		// Off left edge
		cannonball.x > GAME_WIDTH + cannonball.width / 2; // Off right edge
		if (wasOnScreen && isOffScreen) {
			// Cannonball is off-screen, destroy it and remove from the array.
			cannonball.destroy();
			cannonballs.splice(cb, 1);
		} else if (!isOffScreen) {
			// Update last known position only if the cannonball is still potentially on screen
			cannonball.lastY = cannonball.y;
			cannonball.lastX = cannonball.x;
		}
	}
	// 3. Update and check Enemies
	for (var k = enemies.length - 1; k >= 0; k--) {
		var enemy = enemies[k];
		// Note: LK engine calls enemy.update() automatically.
		// Initialize last position if not set.
		if (enemy.lastY === undefined) {
			enemy.lastY = enemy.y;
		}
		// Check if the enemy has reached or passed the bastion line.
		// Use transition detection: was the enemy's bottom edge above the line last frame,
		// and is it on or below the line now?
		var enemyBottomY = enemy.y + enemy.height / 2;
		var enemyLastBottomY = enemy.lastY + enemy.height / 2;
		var wasAboveBastion = enemyLastBottomY < BASTION_Y;
		var isAtOrBelowBastion = enemyBottomY >= BASTION_Y;
		if (wasAboveBastion && isAtOrBelowBastion) {
			// Enemy reached the bastion! Game Over.
			LK.getSound('gameOverSfx').play(); // Play game over sound effect.
			LK.showGameOver(); // Trigger the engine's game over sequence.
			// Calculate gold earned
			var goldEarned = Math.floor(currentScore / 5);
			playerGold += goldEarned;
			storage.playerGold = playerGold; // Save gold to storage
			// Save relics to storage using safe serialization
			try {
				var relicsData = {};
				relicsData.damage_level = playerRelics.damage.level;
				relicsData.damage_enabled = playerRelics.damage.enabled;
				relicsData.slowdown_level = playerRelics.slowdown.level;
				relicsData.slowdown_enabled = playerRelics.slowdown.enabled;
				relicsData.green_level = playerRelics.green.level;
				relicsData.green_enabled = playerRelics.green.enabled;
				relicsData.dark_level = playerRelics.dark.level;
				relicsData.dark_enabled = playerRelics.dark.enabled;
				relicsData.dragon_level = playerRelics.dragon.level;
				relicsData.dragon_enabled = playerRelics.dragon.enabled;
				relicsData.reload_level = playerRelics.reload.level;
				relicsData.reload_enabled = playerRelics.reload.enabled;
				relicsData.ammo_level = playerRelics.ammo.level;
				relicsData.ammo_enabled = playerRelics.ammo.enabled;
				relicsData.swordsman_level = playerRelics.swordsman.level;
				relicsData.swordsman_enabled = playerRelics.swordsman.enabled;
				storage.playerRelicsData = relicsData;
			} catch (e) {
				console.log("Error saving relics:", e);
			}
			console.log("Game Over! Earned " + goldEarned + " gold. Total gold: " + playerGold);
			// LK.showGameOver handles game state reset, no need to manually clear arrays here.
			return; // Exit the update loop immediately as the game is over.
		} else {
			// Update last known position if game is not over for this enemy.
			enemy.lastY = enemy.y;
		}
	}
	// 3. Update and check Swordsmen (allies)
	for (var l = swordsmen.length - 1; l >= 0; l--) {
		var swordsman = swordsmen[l];
		// Swordsman update method handles its own lifetime and attacking
		// Check if the swordsman has been destroyed by its lifetime timer
		if (!swordsman.parent) {
			// If it no longer has a parent, it has been destroyed
			swordsmen.splice(l, 1); // Remove swordsman from array
		}
	}
	// 4. Update and check Cannons (allies)
	for (var m = cannons.length - 1; m >= 0; m--) {
		var cannon = cannons[m];
		// Cannons do not have a lifetime timer or destruction logic in this basic version
		// If they had, we'd check !cannon.parent and splice here as in Swordsmen
	}
	// 5. Update and check Wizard Towers (allies)
	for (var wt = wizardTowers.length - 1; wt >= 0; wt--) {
		var tower = wizardTowers[wt];
		// Wizard towers do not have a lifetime timer or destruction logic in this basic version
		// If they had, we'd check !tower.parent and splice here
	}
	// 5.5 Update and check Viking Allies
	for (var va = vikingAllies.length - 1; va >= 0; va--) {
		var viking = vikingAllies[va];
		// Vikings do not have a lifetime timer or destruction logic in this version
		// LK engine calls viking.update() automatically.
	}
	// 5.6 Update and check Angel of Lights (allies)
	for (var angelIdx = angelOfLights.length - 1; angelIdx >= 0; angelIdx--) {
		var angel = angelOfLights[angelIdx];
		// Angels do not have a lifetime timer or destruction logic in this version
		// LK engine calls angel.update() automatically.
	}
	// 5.7 Update and check Bouncy Balls
	for (var bbIdx = bouncyBalls.length - 1; bbIdx >= 0; bbIdx--) {
		var ball = bouncyBalls[bbIdx];
		// LK engine calls ball.update() automatically.
		// Check for collisions with enemies
		for (var j = enemies.length - 1; j >= 0; j--) {
			var enemy = enemies[j];
			if (ball.intersects(enemy)) {
				// Apply damage
				var enemyDefeated = enemy.takeDamage(ball.damage, ball);
				if (enemyDefeated) {
					LK.setScore(LK.getScore() + 1);
					scoreTxt.setText(LK.getScore());
					enemy.destroy();
					enemies.splice(j, 1);
				}
				// Bouncy ball doesn't get destroyed on hit
				LK.effects.flashObject(enemy, 0xFF00FF, 300);
			}
		}
		// Check if ball was destroyed by lifetime
		if (!ball.parent) {
			bouncyBalls.splice(bbIdx, 1);
		}
	}
	// 5.8 Update and check Bombs
	for (var bombIdx = bombs.length - 1; bombIdx >= 0; bombIdx--) {
		var bomb = bombs[bombIdx];
		// LK engine calls bomb.update() automatically.
		// Check if bomb was destroyed after explosion
		if (!bomb.parent) {
			bombs.splice(bombIdx, 1);
		}
	}
	// 5.9 Update and check Bombers
	for (var bomberIdx = bombers.length - 1; bomberIdx >= 0; bomberIdx--) {
		var bomber = bombers[bomberIdx];
		// LK engine calls bomber.update() automatically.
	}
	// 5.10 Update and check XBOWs
	for (var xbowIdx = xbows.length - 1; xbowIdx >= 0; xbowIdx--) {
		var xbow = xbows[xbowIdx];
		// LK engine calls xbow.update() automatically.
	}
	// 6. Update and check Magic Balls
	for (var mb = magicBalls.length - 1; mb >= 0; mb--) {
		var magicBall = magicBalls[mb];
		// Note: LK engine calls magicBall.update() automatically.
		// Initialize last position if it hasn't been set yet (first frame).
		if (magicBall.lastY === undefined) {
			magicBall.lastY = magicBall.y;
		}
		if (magicBall.lastX === undefined) {
			magicBall.lastX = magicBall.x;
		}
		// Check for collisions between the current magic ball and all enemies.
		var hitEnemy = false;
		for (var j = enemies.length - 1; j >= 0; j--) {
			var enemy = enemies[j];
			// Use the intersects method for collision detection.
			if (magicBall.intersects(enemy)) {
				// Collision detected!
				LK.getSound('hit').play(); // Play hit sound.
				// Apply damage (minimal) and slowdown effect to the enemy and check if it was defeated
				var enemyDefeated = enemy.takeDamage(magicBall.damage, magicBall); // Pass the magic ball object as source
				// Check if the magic ball was reflected (takeDamage returns false and magicBall is destroyed)
				if (!enemyDefeated && !magicBall.parent) {
					// Magic ball was reflected, remove it from the array and stop processing
					magicBalls.splice(mb, 1);
					hitEnemy = true; // Mark that this magic ball is done
					break; // Stop checking this magic ball against other enemies as it's destroyed
				}
				if (enemyDefeated) {
					LK.setScore(LK.getScore() + 1); // Increment score.
					scoreTxt.setText(LK.getScore()); // Update score display.
					// Destroy the enemy
					enemy.destroy();
					enemies.splice(j, 1); // Remove enemy from array.
				}
				// Magic balls are destroyed on hit
				magicBall.destroy();
				// Apply Green Slowdown if applicable before destroying magic ball
				if (greenSlowdownEnabled && enemy.tag === 'Green' && enemy.slowTimer <= 0) {
					// Note: Enemy.takeDamage already checks for MagicBall source to apply its default slow.
					// This adds the Green Slowdown effect *on top* if applicable and not already slowed.
					// However, takeDamage applies slow based on MagicBall properties. Let's apply Green Slowdown here explicitly.
					enemy.slowTimer = 10 * 60; // 10 seconds
					enemy.currentSlowAmount = 0.9; // 10% slow
				}
				magicBall.destroy();
				magicBalls.splice(mb, 1); // Remove magic ball from array.
				hitEnemy = true; // Mark that this magic ball is done
				break; // Stop checking this magic ball against other enemies as it's destroyed
			}
		}
		// If the magic ball hit an enemy, it was destroyed, so skip to the next magic ball.
		if (hitEnemy) {
			continue;
		}
		// Check if the magic ball has gone off-screen.
		var wasOnScreen = magicBall.lastY > -magicBall.height / 2 && magicBall.lastX > -magicBall.width / 2 && magicBall.lastX < GAME_WIDTH + magicBall.width / 2;
		var isOffScreen = magicBall.y < -magicBall.height / 2 ||
		// Off top edge
		magicBall.x < -magicBall.width / 2 ||
		// Off left edge
		magicBall.x > GAME_WIDTH + magicBall.width / 2; // Off right edge
		if (wasOnScreen && isOffScreen) {
			// Magic ball is off-screen, destroy it and remove from the array.
			magicBall.destroy();
			magicBalls.splice(mb, 1);
		} else if (!isOffScreen) {
			// Update last known position only if the magic ball is still potentially on screen
			magicBall.lastY = magicBall.y;
			magicBall.lastX = magicBall.x;
		}
	}
	// 6.5 Update and check Viking Axes
	for (var axeIdx = vikingAxes.length - 1; axeIdx >= 0; axeIdx--) {
		var axe = vikingAxes[axeIdx];
		// Note: LK engine calls axe.update() automatically.
		// Initialize last position if it hasn't been set yet (first frame).
		if (axe.lastY === undefined) {
			axe.lastY = axe.y;
		}
		if (axe.lastX === undefined) {
			axe.lastX = axe.x;
		}
		// Check for collisions between the current axe and all enemies.
		var hitEnemyAxe = false;
		for (var j = enemies.length - 1; j >= 0; j--) {
			var enemy = enemies[j];
			if (axe.intersects(enemy)) {
				// Collision detected!
				LK.getSound('hit').play(); // Play hit sound.
				// Apply Green Killer bonus if applicable (Vikings benefit too)
				var damageToDealAxe = axe.damage;
				if (greenKillerEnabled && enemy.tag === 'Green') {
					damageToDealAxe *= 1.5; // Apply 50% damage bonus
				}
				// Apply damage and check if defeated
				var enemyDefeated = enemy.takeDamage(damageToDealAxe, axe); // Pass axe as source for potential effects
				// Check if the axe was reflected (takeDamage returns false and axe is destroyed)
				if (!enemyDefeated && !axe.parent) {
					// Axe was reflected, remove it from the array and stop processing
					vikingAxes.splice(axeIdx, 1);
					hitEnemyAxe = true; // Mark that this axe is done
					break; // Stop checking this axe against other enemies as it's destroyed
				}
				if (enemyDefeated) {
					LK.setScore(LK.getScore() + 1); // Increment score.
					scoreTxt.setText(LK.getScore()); // Update score display.
					enemy.destroy();
					enemies.splice(j, 1); // Remove enemy from array.
				}
				// Handle axe piercing
				axe.pierceLeft--; // Decrease remaining pierces
				if (axe.pierceLeft <= 0) {
					// Axe has no pierces left, destroy it
					axe.destroy();
					vikingAxes.splice(axeIdx, 1); // Remove axe from array.
					hitEnemyAxe = true; // Mark that this axe is done
					break; // Stop checking this axe against other enemies
				} else {
					// Axe pierced this enemy and can continue
					// Potentially apply Green Slowdown if enabled
					if (greenSlowdownEnabled && enemy.tag === 'Green' && enemy.slowTimer <= 0) {
						enemy.slowTimer = 10 * 60;
						enemy.currentSlowAmount = 0.9;
					}
				}
			}
		}
		// If the axe hit and was destroyed, skip to the next axe.
		if (hitEnemyAxe) {
			continue;
		}
		// Check if the axe has gone off-screen.
		var wasOnScreenAxe = axe.lastY > -axe.height / 2 && axe.lastX > -axe.width / 2 && axe.lastX < GAME_WIDTH + axe.width / 2;
		var isOffScreenAxe = axe.y < -axe.height / 2 || axe.y > GAME_HEIGHT + axe.height / 2 || axe.x < -axe.width / 2 || axe.x > GAME_WIDTH + axe.width / 2;
		if (wasOnScreenAxe && isOffScreenAxe) {
			axe.destroy();
			vikingAxes.splice(axeIdx, 1);
		} else if (!isOffScreenAxe) {
			axe.lastY = axe.y;
			axe.lastX = axe.x;
		}
	}
	// 6.6 Update and check Darts
	for (var dartIdx = darts.length - 1; dartIdx >= 0; dartIdx--) {
		var dart = darts[dartIdx];
		// Note: LK engine calls dart.update() automatically.
		// Initialize last position if it hasn't been set yet (first frame).
		if (dart.lastY === undefined) {
			dart.lastY = dart.y;
		}
		if (dart.lastX === undefined) {
			dart.lastX = dart.x;
		}
		// Check for collisions between the current dart and all enemies.
		var hitEnemyDart = false;
		for (var j = enemies.length - 1; j >= 0; j--) {
			var enemy = enemies[j];
			if (dart.intersects(enemy)) {
				// Collision detected!
				LK.getSound('hit').play(); // Play hit sound.
				// Calculate damage, applying bonus against Green enemies
				var damageToDealDart = dart.damage;
				var greenDamageMultiplier = 2; // Base multiplier for darts vs Green enemies
				// Apply Green Relic damage bonus if enabled and enemy is Green-tagged
				if (playerRelics.green.enabled && enemy.tag === 'Green') {
					greenDamageMultiplier += playerRelics.green.level * 0.02; // Additional damage multiplier from relic
				}
				if (enemy.tag === 'Green') {
					damageToDealDart *= greenDamageMultiplier; // Apply calculated multiplier
				}
				// Apply damage and check if defeated
				var enemyDefeated = enemy.takeDamage(damageToDealDart, dart); // Pass dart as source
				// Check if the dart was reflected (takeDamage returns false and dart is destroyed)
				if (!enemyDefeated && !dart.parent) {
					// Dart was reflected, remove it from the array and stop processing
					darts.splice(dartIdx, 1);
					hitEnemyDart = true; // Mark that this dart is done
					break; // Stop checking this dart against other enemies
				}
				if (enemyDefeated) {
					LK.setScore(LK.getScore() + 1); // Increment score.
					scoreTxt.setText(LK.getScore()); // Update score display.
					enemy.destroy();
					enemies.splice(j, 1); // Remove enemy from array.
				}
				// Darts are destroyed on hit
				dart.destroy();
				// Apply Green Slowdown if applicable before destroying dart
				if (greenSlowdownEnabled && enemy.tag === 'Green' && enemy.slowTimer <= 0) {
					enemy.slowTimer = 10 * 60;
					enemy.currentSlowAmount = 0.9;
				}
				darts.splice(dartIdx, 1); // Remove dart from array.
				hitEnemyDart = true; // Mark that this dart is done
				break; // Stop checking this dart against other enemies
			}
		}
		// If the dart hit and was destroyed, skip to the next dart.
		if (hitEnemyDart) {
			continue;
		}
		// Check if the dart has gone off-screen.
		var wasOnScreenDart = dart.lastY > -dart.height / 2 && dart.lastX > -dart.width / 2 && dart.lastX < GAME_WIDTH + dart.width / 2;
		var isOffScreenDart = dart.y < -dart.height / 2 || dart.y > GAME_HEIGHT + dart.height / 2 || dart.x < -dart.width / 2 || dart.x > GAME_WIDTH + dart.width / 2;
		if (wasOnScreenDart && isOffScreenDart) {
			dart.destroy();
			darts.splice(dartIdx, 1);
		} else if (!isOffScreenDart) {
			dart.lastY = dart.y;
			dart.lastX = dart.x;
		}
	}
	// 7. Spawn new Enemies periodically
	// Use LK.ticks and the spawn interval. Ensure interval doesn't go below minimum.
	if (LK.ticks % Math.max(minEnemySpawnInterval, Math.floor(enemySpawnInterval)) === 0) {
		var currentScore = LK.getScore();
		var baseSpeedForSpawn = Math.min(maxEnemySpeed, currentEnemySpeed); // Base speed adjusted by game difficulty progression
		// Determine if this spawn *could* be a boss (e.g., every 7th spawn after score 10)
		var potentialBoss = (enemies.length + 1) % 7 === 0 && currentScore >= 10;
		var typeToSpawn = 'swordsman'; // Default type
		var enemyHealth = 1; // Default health
		var enemyDodgeChance = 0; // Default dodge chance
		var enemySpeed = baseSpeedForSpawn; // Start with base speed
		// Determine base type based on score thresholds and randomness
		var possibleTypes = ['swordsman'];
		if (currentScore >= 10) {
			possibleTypes.push('spearman');
		}
		if (currentScore >= 15) {
			possibleTypes.push('thief');
		}
		if (currentScore >= 23) {
			possibleTypes.push('knight');
		}
		if (currentScore >= 25) {
			possibleTypes.push('wizard');
		} // Wizards start appearing at score 25
		if (currentScore >= 30) {
			possibleTypes.push('shield');
		} // Shields start appearing at score 30
		if (currentScore >= 35) {
			possibleTypes.push('shaman'); // Shaman appears at score 35
			console.log("Shaman added to possible enemy types");
		}
		if (currentScore >= 55) {
			possibleTypes.push('dark_bowman'); // Dark bowman appears at score 55
			possibleTypes.push('dark_spearman'); // Dark Spearman appears at score 55
		}
		if (currentScore >= 69) {
			possibleTypes.push('jester'); // Jester appears at score 69
		}
		if (currentScore >= 100) {
			possibleTypes.push('elite_knight'); // Elite Knights start appearing at score 100
		}
		if (currentScore >= 134) {
			possibleTypes.push('dragon'); // Dragon appears at score 134
		}
		if (currentScore >= 112) {
			possibleTypes.push('elite_shield'); // Elite Shields appear at score 112
		}
		if (currentScore >= 125) {
			// War Elephant appears at score 125
			possibleTypes.push('war_elephant');
			// Baby Dragon also appears at score 125 (same as war elephant)
			possibleTypes.push('baby_dragon');
		}
		if (currentScore >= 145) {
			possibleTypes.push('dark_war_elephant'); // Dark War Elephant appears at score 145
		}
		if (currentScore >= 154) {
			// Hot Air Balloon appears at score 100
			possibleTypes.push('hot_air_balloon');
		}
		if (currentScore >= 27) {
			possibleTypes.push('flag_bearer'); // Flag Bearer appears at score 27
		}
		// Check if Battle Horn is active - if so, make half of spawns swordsmen, rest random
		if (battleHornEnabled) {
			// 50% chance to force swordsman, 50% chance to pick random
			if (Math.random() < 0.5) {
				typeToSpawn = 'swordsman';
			} else {
				var chosenTypeIndex = Math.floor(Math.random() * possibleTypes.length);
				typeToSpawn = possibleTypes[chosenTypeIndex];
			}
		} else {
			// Randomly select a type from the available pool for this score level
			var chosenTypeIndex = Math.floor(Math.random() * possibleTypes.length);
			typeToSpawn = possibleTypes[chosenTypeIndex];
		}
		// Set stats based on chosen type and apply score-based scaling
		if (typeToSpawn === 'knight') {
			var baseKnightHP = 5;
			var hpIncreaseIntervalKnight = 30; // Health increases every 30 score points after appearing
			var hpIncreasesKnight = Math.floor(Math.max(0, currentScore - 23) / hpIncreaseIntervalKnight);
			enemyHealth = baseKnightHP + hpIncreasesKnight * 5;
			enemySpeed *= 0.9; // Knights are slightly slower than base swordsman speed
		} else if (typeToSpawn === 'thief') {
			enemyHealth = 1; // Thieves are fragile
			enemyDodgeChance = 0.10; // 10% dodge chance
			var speedIncreaseIntervalThief = 25; // Speed increases every 25 score points after appearing
			var speedIncreasePercentThief = 0.05; // 5% speed increase each time
			var speedIncreasesThief = Math.floor(Math.max(0, currentScore - 15) / speedIncreaseIntervalThief);
			var thiefSpeedMultiplier = Math.pow(1 + speedIncreasePercentThief, speedIncreasesThief);
			enemySpeed *= 1.2 * thiefSpeedMultiplier; // Thieves are faster base + scaling speed
		} else if (typeToSpawn === 'shield') {
			var baseShieldHP = 20;
			var hpIncreaseIntervalShield = 35; // Gains HP every 35 score points after appearing
			var hpIncreasesShield = Math.floor(Math.max(0, currentScore - 30) / hpIncreaseIntervalShield);
			enemyHealth = baseShieldHP + hpIncreasesShield * 20;
			enemySpeed *= 0.5; // Shield enemies are very slow
			enemyDodgeChance = 0;
		} else if (typeToSpawn === 'shaman') {
			var baseShamanHP = 2;
			var statIncreaseIntervalShaman = 10; // Gains stats every 10 score points after appearing
			var statIncreasesShaman = Math.floor(Math.max(0, currentScore - 35) / statIncreaseIntervalShaman);
			enemyHealth = baseShamanHP + statIncreasesShaman * 1; // Gains 1 HP per interval
			enemySpeed *= 0.8 * Math.pow(1.04, statIncreasesShaman); // Base speed, gains 4% speed per interval
			enemyDodgeChance = 0; // Shaman cannot dodge
		} else if (typeToSpawn === 'wizard') {
			var baseWizardHP = 2;
			var statIncreaseIntervalWizard = 10; // Gains stats every 10 score points after appearing
			var statIncreasesWizard = Math.floor(Math.max(0, currentScore - 25) / statIncreaseIntervalWizard);
			enemyHealth = baseWizardHP + statIncreasesWizard * 1; // Gains 1 HP per interval
			enemySpeed *= 0.7 * Math.pow(1.05, statIncreasesWizard); // Slow base, gains 5% speed per interval
			enemyDodgeChance = 0;
		} else if (typeToSpawn === 'elite_knight') {
			var baseEliteKnightHP = 45;
			var hpIncreaseIntervalElite = 30; // Gains HP every 30 score points after appearing
			var hpIncreasesElite = Math.floor(Math.max(0, currentScore - 100) / hpIncreaseIntervalElite);
			enemyHealth = baseEliteKnightHP + hpIncreasesElite * 15;
			enemySpeed *= 0.85; // Slightly slower than base knight speed
			enemyDodgeChance = 0;
		} else if (typeToSpawn === 'elite_shield') {
			var baseEliteShieldHP = 200; // Starts with 200 HP
			var hpIncreaseIntervalEliteShield = 20; // Gains HP every 20 score points after appearing
			var hpIncreasesEliteShield = Math.floor(Math.max(0, currentScore - 112) / hpIncreaseIntervalEliteShield);
			enemyHealth = baseEliteShieldHP + hpIncreasesEliteShield * 50; // Gains 50 HP per interval
			enemySpeed *= 0.4; // Elite Shield enemies are slower than regular shield enemies
			enemyDodgeChance = 0;
		} else if (typeToSpawn === 'spearman') {
			var baseSpearmanHP = 2;
			var hpIncreaseIntervalSpearman = 10; // Gains HP every 10 score points after appearing
			var hpIncreasesSpearman = Math.floor(Math.max(0, currentScore - 10) / hpIncreaseIntervalSpearman);
			enemyHealth = baseSpearmanHP + hpIncreasesSpearman * 3; // Gains 3 HP per interval
			var speedIncreaseIntervalSpearman = 10; // Gains speed every 10 score points after appearing
			var speedIncreasePercentSpearman = 0.05; // 5% speed increase each time
			var speedIncreasesSpearman = Math.floor(Math.max(0, currentScore - 10) / speedIncreaseIntervalSpearman);
			var spearmanSpeedMultiplier = Math.pow(1 + speedIncreasePercentSpearman, speedIncreasesSpearman);
			enemySpeed *= 1.0 * spearmanSpeedMultiplier; // Base speed + scaling speed
			enemyDodgeChance = 0;
		} else if (typeToSpawn === 'war_elephant') {
			var baseElephantHP = 500;
			var hpIncreaseIntervalElephant = 15; // Gains HP every 15 score points after appearing
			var hpIncreasesElephant = Math.floor(Math.max(0, currentScore - 125) / hpIncreaseIntervalElephant);
			enemyHealth = baseElephantHP + hpIncreasesElephant * 100; // Gains 100 HP per interval
			enemySpeed *= 0.3; // War Elephants are very slow
			enemyDodgeChance = 0;
			// Note: War elephant death spawns spearmen - this will be handled in the Enemy death logic.
		} else if (typeToSpawn === 'hot_air_balloon') {
			enemyHealth = 1; // Always has 1 HP
			enemySpeed *= 0.2; // Very slow movement
			enemyDodgeChance = 0;
			// Note: Hot air balloon death spawns 5 random non-green enemies - handled in Enemy death logic
		} else if (typeToSpawn === 'dark_bowman') {
			var baseDarkBowmanHP = 5;
			var statIncreaseIntervalBowman = 10; // Gains stats every 10 score points after appearing
			var statIncreasesBowman = Math.floor(Math.max(0, currentScore - 55) / statIncreaseIntervalBowman);
			enemyHealth = baseDarkBowmanHP + statIncreasesBowman * 3; // Gains 3 HP per interval
			var speedIncreasePercentBowman = 0.05; // 5% speed increase each time
			var bowmanSpeedMultiplier = Math.pow(1 + speedIncreasePercentBowman, statIncreasesBowman);
			enemySpeed *= 1.1 * bowmanSpeedMultiplier; // Slightly faster than base speed + scaling
			enemyDodgeChance = 0;
			// Note: Dark bowman has Black tag making it immune to arrows
		} else if (typeToSpawn === 'jester') {
			var baseJesterHP = 2;
			enemyHealth = baseJesterHP; // Jester HP doesn't scale with score
			var baseJesterSpeed = baseSpeedForSpawn * 1.1; // Jester starts faster
			var speedIncreaseIntervalJester = 12; // Gains speed every 12 score points after appearing
			var speedIncreasePercentJester = 0.03; // 3% speed increase each time
			var speedIncreasesJester = Math.floor(Math.max(0, currentScore - 69) / speedIncreaseIntervalJester);
			enemySpeed = baseJesterSpeed * Math.pow(1 + speedIncreasePercentJester, speedIncreasesJester);
			enemyDodgeChance = 0.30; // 30% dodge chance
			// The reflectChance is set in the Enemy class constructor based on type, no need to set here.
		} else if (typeToSpawn === 'dark_war_elephant') {
			var baseDarkElephantHP = 450;
			var hpIncreaseIntervalDarkElephant = 10; // Gains HP every 10 score points after appearing
			var hpIncreasesDarkElephant = Math.floor(Math.max(0, currentScore - 120) / hpIncreaseIntervalDarkElephant);
			enemyHealth = baseDarkElephantHP + hpIncreasesDarkElephant * 80; // Gains 80 HP per interval
			enemySpeed *= 0.3; // Dark War Elephants are very slow
			enemyDodgeChance = 0;
			// Note: Dark War elephant death spawns dark bowmen - this will be handled in the Enemy death logic.
		} else if (typeToSpawn === 'dark_spearman') {
			var baseDarkSpearmanHP = 15;
			var baseDarkSpearmanSpeedMultiplier = 1.2;
			var statIncreaseIntervalDarkSpearman = 10; // Gains stats every 10 score points after appearing
			var statIncreasesDarkSpearman = Math.floor(Math.max(0, currentScore - 55) / statIncreaseIntervalDarkSpearman);
			enemyHealth = baseDarkSpearmanHP + statIncreasesDarkSpearman * 5; // Gains 5 HP per interval
			var darkSpearmanSpeedBonus = Math.pow(1 + 0.03, statIncreasesDarkSpearman); // Gains 3% speed per interval
			enemySpeed *= baseDarkSpearmanSpeedMultiplier * darkSpearmanSpeedBonus;
			enemyDodgeChance = 0;
			// Tag 'Black' is set in Enemy constructor
		} else if (typeToSpawn === 'dragon') {
			var baseDragonHP = 250;
			var hpIncreaseIntervalDragon = 15; // Gains HP every 15 score points after appearing
			var hpIncreasesDragon = Math.floor(Math.max(0, currentScore - 100) / hpIncreaseIntervalDragon);
			enemyHealth = baseDragonHP + hpIncreasesDragon * 50; // Gains 50 HP per interval
			enemySpeed *= 0.9; // Dragons are moderately fast
			enemyDodgeChance = 0.40; // 40% dodge chance
			// Tag 'Dragon' could be set in Enemy constructor if needed for other mechanics
		} else if (typeToSpawn === 'flag_bearer') {
			var baseFlagBearerHP = 5;
			var hpIncreaseIntervalFlagBearer = 10; // Gains HP every 10 score points after appearing
			var hpIncreasesFlagBearer = Math.floor(Math.max(0, currentScore - 27) / hpIncreaseIntervalFlagBearer);
			enemyHealth = baseFlagBearerHP + hpIncreasesFlagBearer * 2; // Gains 2 HP per interval
			var speedIncreaseIntervalFlagBearer = 10; // Gains speed every 10 score points
			var speedIncreasesFlagBearer = Math.floor(Math.max(0, currentScore - 27) / speedIncreaseIntervalFlagBearer);
			var flagBearerSpeedMultiplier = Math.pow(1.03, speedIncreasesFlagBearer); // 3% speed increase per interval
			enemySpeed *= 0.8 * flagBearerSpeedMultiplier; // Slower base speed but increases over time
			enemyDodgeChance = 0;
		} else if (typeToSpawn === 'baby_dragon') {
			var baseBabyDragonHP = 50;
			var hpIncreaseIntervalBabyDragon = 9; // Gains HP every 9 score points after appearing
			var hpIncreasesBabyDragon = Math.floor(Math.max(0, currentScore - 125) / hpIncreaseIntervalBabyDragon);
			enemyHealth = baseBabyDragonHP + hpIncreasesBabyDragon * 10; // Gains 10 HP per interval
			var speedIncreaseIntervalBabyDragon = 9; // Gains speed every 9 score points
			var speedIncreasesBabyDragon = Math.floor(Math.max(0, currentScore - 125) / speedIncreaseIntervalBabyDragon);
			var babyDragonSpeedMultiplier = Math.pow(1.02, speedIncreasesBabyDragon); // 2% speed increase per interval
			enemySpeed *= 1.1 * babyDragonSpeedMultiplier; // Faster than regular dragon
			enemyDodgeChance = 0.25; // 25% dodge chance
		} else {
			// Swordsman (default)
			enemyHealth = 1;
			// Speed remains baseSpeedForSpawn initially
		}
		// Check if this spawn should be overridden to be a Boss
		if (potentialBoss) {
			typeToSpawn = 'boss'; // Set type to boss
			enemyHealth = 5 + Math.floor(currentScore / 8); // Boss health scales significantly with score
			enemySpeed = baseSpeedForSpawn * 0.7; // Bosses are slower but much tougher (reset speed based on base)
			enemyDodgeChance = 0; // Bosses typically don't dodge
		}
		// Apply the global Sabotage speed multiplier AFTER type-specific adjustments
		enemySpeed *= enemySpeedMultiplier;
		// Create the new enemy instance with the calculated stats
		var newEnemy;
		if (typeToSpawn === 'flag_bearer') {
			newEnemy = new FlagBearer();
			newEnemy.speed = enemySpeed;
			newEnemy.baseSpeed = enemySpeed;
			newEnemy.health = enemyHealth;
			newEnemy.maxHealth = enemyHealth;
			newEnemy.dodgeChance = enemyDodgeChance;
		} else if (typeToSpawn === 'baby_dragon') {
			newEnemy = new BabyDragon();
			newEnemy.speed = enemySpeed;
			newEnemy.baseSpeed = enemySpeed;
			newEnemy.health = enemyHealth;
			newEnemy.maxHealth = enemyHealth;
			newEnemy.dodgeChance = enemyDodgeChance;
		} else {
			newEnemy = new Enemy(typeToSpawn, enemySpeed, enemyHealth, enemyDodgeChance);
		}
		// Position the new enemy at the top, random horizontal position with padding
		// Use the actual width of the created enemy's graphic for padding calculation
		// Need to access width after creation, use a sensible default or estimate if needed before creation
		var tempAsset = LK.getAsset(newEnemy.assetId || 'enemy', {}); // Get asset dimensions (might need refinement if assetId isn't on newEnemy yet)
		var spawnPadding = (tempAsset ? tempAsset.width / 2 : 100) + 20; // Use default if asset not found easily
		newEnemy.x = spawnPadding + Math.random() * (GAME_WIDTH - 2 * spawnPadding);
		newEnemy.y = -(tempAsset ? tempAsset.height / 2 : 100); // Start just above the top edge.
		// Initialize last position for state tracking (used for bastion collision check).
		newEnemy.lastY = newEnemy.y;
		// Add the new enemy to the game scene and the tracking array.
		game.addChild(newEnemy);
		enemies.push(newEnemy);
		// Increase difficulty for the next spawn: decrease spawn interval and increase base speed.
		// These affect the *next* potential spawn's base calculations.
		enemySpawnInterval -= enemySpawnRateDecrease;
		currentEnemySpeed += enemySpeedIncrease;
	}
};
// --- Swordsman Relic Initial Setup ---
if (playerRelics.swordsman.enabled && playerRelics.swordsman.level > 0) {
	// Spawn permanent swordsman for swordsman relic
	var permanentSwordsman = new Swordsman();
	permanentSwordsman.x = FIRING_POS_X + 100; // Position near player
	permanentSwordsman.y = FIRING_POS_Y - 50;
	permanentSwordsman.lifetime = Infinity; // Permanent swordsman
	permanentSwordsman.attackDamage = 1 + (playerRelics.swordsman.level - 1) * 2; // Base damage +2 per level after first
	game.addChild(permanentSwordsman);
	swordsmen.push(permanentSwordsman);
}
// --- Initial Game Setup ---
// Set the initial score text based on the starting score (which is 0).
scoreTxt.setText(LK.getScore());
// Set the initial ammo display.
if (ammoTxt) {
	// Ensure ammoTxt is initialized
	ammoTxt.setText('Ammo: ' + maxArrowsBeforeCooldown);
}
;
// Play the background music.
// Check if we need to show a title screen first
if (!isGameStarted) {// Assuming a flag 'isGameStarted' for title screen state
	// Don't play music immediately if showing title screen
} else {
	LK.playMusic('Gamemusic');
	;
}
// Placeholder for the title screen container
var titleScreen = null;
// Flag to track game start state
var isGameStarted = false;
// Function to show the title screen
function showTitleScreen() {
	isGameStarted = false; // Ensure game is not started
	// Create the title screen container
	titleScreen = new Container();
	titleScreen.x = GAME_WIDTH / 2;
	titleScreen.y = GAME_HEIGHT / 2;
	game.addChild(titleScreen);
	// Add title text
	var titleText = new Text2('Defend Your Bastion!', {
		size: 120,
		fill: 0xFFFFFF
	});
	titleText.anchor.set(0.5, 0.5);
	titleText.y = -200;
	titleScreen.addChild(titleText);
	// Add a simple instruction text
	var instructionText = new Text2('Tap to Start', {
		size: 60,
		fill: 0xCCCCCC
	});
	instructionText.anchor.set(0.5, 0.5);
	instructionText.y = 100;
	titleScreen.addChild(instructionText);
	// Make the title screen interactive to start the game
	titleScreen.interactive = true;
	titleScreen.down = function () {
		startGame(); // Start the game when tapped
	};
	// Pause game logic while title screen is active
	isUpgradePopupActive = true; // Reusing this flag to pause game logic
}
// Function to start the game
function startGame() {
	isGameStarted = true; // Set game started flag
	isUpgradePopupActive = false; // Unpause game logic
	if (titleScreen) {
		titleScreen.destroy();
		titleScreen = null;
	}
	// Reset game state if needed (LK might handle this on game start)
	// Play game music
	LK.playMusic('Gamemusic');
}
// Initially show the title screen
showTitleScreen();