/**** 
* Plugins
****/ 
var tween = LK.import("@upit/tween.v1");
var storage = LK.import("@upit/storage.v1", {
	highScore: 0
});

/**** 
* Classes
****/ 
var AuditorBot = Container.expand(function () {
	var self = Container.call(this);
	self.walkFrames = ['enemyAuditorBot', 'enemyAuditorBot_walk_1', 'enemyAuditorBot_walk_2']; // Animation frames
	self.currentAnimFrame = 0;
	self.animationSpeed = 8;
	self.animationCounter = 0;
	self.graphic = self.attachAsset(self.walkFrames[0], {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.health = 45; // High health
	self.speed = 1.0; // Slow speed
	self.value = 30; // High currency reward
	self.isFlying = false;
	self.currentPathIndex = 0;
	self.update = function () {
		// Check if pathPoints is loaded and valid
		if (!pathPoints || pathPoints.length === 0) {
			return;
		}
		if (self.currentPathIndex < pathPoints.length) {
			var target = pathPoints[self.currentPathIndex];
			if (!target) {
				// Safety check
				self.currentPathIndex++;
				return;
			}
			var dx = target.x - self.x;
			var dy = target.y - self.y;
			var distance = Math.sqrt(dx * dx + dy * dy);
			// Use a slightly larger threshold for path progression
			if (distance < self.speed * 1.5) {
				// Adjusted threshold
				self.currentPathIndex++;
				// Check if enemy reached the goal
				if (self.currentPathIndex >= pathPoints.length) {
					playerLives--;
					livesText.setText("Lives: " + playerLives);
					LK.getSound('enemyReachGoal').play();
					if (playerLives <= 0) {
						// Game over
						if (LK.getScore() > storage.highScore) {
							storage.highScore = LK.getScore();
						}
						LK.showGameOver();
					}
					self.destroy();
					return;
				}
			} else {
				// Move towards the target point
				dx = dx / distance * self.speed * gameSpeedMultiplier;
				dy = dy / distance * self.speed * gameSpeedMultiplier;
				self.x += dx;
				self.y += dy;
			}
		} else {
			// If somehow past the end of path but not destroyed, remove it
			console.log("Enemy past end of path, destroying.");
			self.destroy();
		}
		// --- Animation Logic ---
		if (self.walkFrames && self.walkFrames.length > 1) {
			// Only animate if there's more than one frame
			self.animationCounter += gameSpeedMultiplier; // Respect game speed
			if (self.animationCounter >= self.animationSpeed) {
				self.animationCounter = 0;
				self.currentAnimFrame = (self.currentAnimFrame + 1) % self.walkFrames.length;
				// Use remove and re-attach method for animation frames
				var newAsset = self.walkFrames[self.currentAnimFrame];
				if (self.graphic && self.graphic.parent) {
					self.graphic.parent.removeChild(self.graphic);
					self.graphic = self.attachAsset(newAsset, {
						anchorX: 0.5,
						anchorY: 0.5
					});
				}
			}
		}
		// --- End Animation Logic ---
	};
	self.takeDamage = function (amount) {
		self.health -= amount;
		// Flash red when taking damage
		LK.effects.flashObject(self, 0xff0000, 200);
		if (self.health <= 0 && self.parent) {
			// Added check for self.parent before accessing currency
			// Determine number of coins to drop based on enemy value
			var numCoins = Math.ceil(self.value / 5); // 1 coin per 5 value, min 1
			if (numCoins < 1) {
				numCoins = 1;
			}
			// Spawn multiple coins
			for (var i = 0; i < numCoins; i++) {
				var coin = new DogeCoin(self.x, self.y, Math.floor(self.value / numCoins));
				if (game.coinLayer) {
					game.coinLayer.addChild(coin);
				} else {
					coinLayer.addChild(coin);
				}
			}
			// Score still goes up immediately
			LK.setScore(LK.getScore() + self.value);
			scoreText.setText("Score: " + LK.getScore());
			LK.getSound('enemyDeath').play();
			self.destroy();
		}
	};
	return self;
});
var BarkWave = Container.expand(function () {
	var self = Container.call(this);
	var graphic = self.attachAsset('barkWave', {
		anchorX: 0.5,
		anchorY: 0.5,
		alpha: 0.5
	});
	self.damage = 2; // Slightly increased damage for manual ability
	self.duration = 30; // frames
	self.radius = 100;
	self.maxRadius = 350; // Slightly larger radius for manual ability
	self.update = function () {
		self.radius += 15 * gameSpeedMultiplier; // Expand slightly faster
		graphic.scaleX = self.radius / 100;
		graphic.scaleY = self.radius / 100;
		graphic.alpha -= 0.017 * gameSpeedMultiplier;
		// Check for enemies in range ONCE per enemy per wave activation
		// To avoid hitting the same enemy multiple times with one wave
		if (!self.enemiesHit) {
			self.enemiesHit = [];
		} // Initialize if needed
		for (var i = 0; i < enemies.length; i++) {
			var enemy = enemies[i];
			// Only check if enemy hasn't been hit by this wave yet
			if (self.enemiesHit.indexOf(enemy) === -1) {
				var dx = enemy.x - self.x;
				var dy = enemy.y - self.y;
				var distance = Math.sqrt(dx * dx + dy * dy);
				if (distance < self.radius) {
					enemy.takeDamage(self.damage);
					self.enemiesHit.push(enemy); // Mark enemy as hit
				}
			}
		}
		self.duration -= gameSpeedMultiplier;
		if (self.duration <= 0 || self.radius >= self.maxRadius) {
			self.destroy();
		}
	};
	return self;
});
// --- REPLACE THE ENTIRE BuildSpot CLASS DEFINITION WITH THIS ---
var BuildSpot = Container.expand(function () {
	var self = Container.call(this);
	self.graphic = self.attachAsset('buildSpot', {
		anchorX: 0.5,
		anchorY: 0.5,
		alpha: 0.5
	});
	self.graphic.interactive = true; // Ensure the graphic is interactive
	self.graphic.interactive = true; // Ensure the graphic is interactive
	self.hasTower = false;
	self.tower = null; // Reference to the tower built on this spot
	self.selectionIconContainer = null;
	self.upgradeMenuContainer = null;
	self.actionIconContainer = null; // Container for upgrade/sell icons
	self.areIconsVisible = false;
	self.isUpgradeMenuVisible = false;
	self.areActionIconsVisible = false; // Flag for upgrade/sell icons
	self.showSelectionIcons = function () {
		if (self.hasTower || self.areIconsVisible) {
			return;
		}
		if (currentActiveBuildSpot && currentActiveBuildSpot !== self) {
			currentActiveBuildSpot.hideSelectionIcons();
			if (currentActiveBuildSpot.isUpgradeMenuVisible) {
				currentActiveBuildSpot.hideUpgradeMenu();
			}
			if (currentActiveBuildSpot.areActionIconsVisible) {
				currentActiveBuildSpot.hideTowerActionIcons();
			}
		}
		currentActiveBuildSpot = self;
		self.selectionIconContainer = new Container();
		self.selectionIconContainer.x = self.x; // Position container AT the BuildSpot's x (in 'level' space)
		self.selectionIconContainer.y = self.y; // Position container AT the BuildSpot's y (in 'level' space)
		// Add to the SAME parent as the BuildSpot (e.g., 'level').
		// This ensures icons scroll with the game world.
		if (self.parent) {
			// BuildSpot should have a parent (level)
			self.parent.addChild(self.selectionIconContainer);
		} else {
			game.addChild(self.selectionIconContainer); // Fallback to game, but level is better
		}
		for (var i = 0; i < ICON_SELECT_OFFSETS.length; i++) {
			var offsetData = ICON_SELECT_OFFSETS[i];
			var towerTypeKey = offsetData.towerKey;
			var towerInfo = TOWER_DATA[towerTypeKey];
			if (!towerInfo || !towerInfo.levels || !towerInfo.levels[0] || !towerInfo.iconAsset) {
				// Visual error or skip
				var err = new Text2("Data? " + towerTypeKey, {
					size: 10,
					fill: 0xff0000
				});
				err.x = offsetData.x;
				err.y = offsetData.y;
				self.selectionIconContainer.addChild(err);
				continue;
			}
			var cost = towerInfo.levels[0].cost;
			// Create the icon graphic directly (no extra container per icon needed)
			var iconGraphic = self.selectionIconContainer.attachAsset(towerInfo.iconAsset, {
				anchorX: 0.5,
				anchorY: 0.5,
				scaleX: 1.3,
				scaleY: 1.3
			});
			iconGraphic.x = offsetData.x; // Position relative to selectionIconContainer's origin
			iconGraphic.y = offsetData.y; // (which is the BuildSpot's center)
			iconGraphic.interactive = true;
			iconGraphic.towerTypeKey = towerTypeKey; // Store for click
			// Add cost text AS A CHILD of the iconGraphic (or selectionIconContainer)
			var costText = new Text2("$" + cost, {
				size: 20,
				fill: 0xFFFFFF,
				stroke: 0x000000,
				strokeThickness: 2
			});
			costText.anchor.set(0.5, -0.7); // Position below the icon's center
			iconGraphic.addChild(costText); // Text is child of icon, moves with it.
			if (currency < cost) {
				iconGraphic.alpha = 0.4;
				iconGraphic.interactive = false;
			} else {
				iconGraphic.alpha = 1.0;
			}
			iconGraphic.down = function () {
				var buildCost = TOWER_DATA[this.towerTypeKey].levels[0].cost;
				if (currency >= buildCost) {
					self.buildSelectedTower(this.towerTypeKey);
					// No need to call hideSelectionIcons here, game.down will handle it
					// because the click was on an interactive element.
				} else {
					var tempIconForPos = this; // 'this' is the iconGraphic
					var tempParentPos = tempIconForPos.parent.localToGlobal({
						x: tempIconForPos.x,
						y: tempIconForPos.y
					});
					var screenY = tempParentPos.y + game.y;
					spawnFloatingText("Need More $!", tempParentPos.x, screenY - 30, {
						fill: 0xFF0000
					});
				}
				// Always hide icons after a choice or attempted choice on an icon
				self.hideSelectionIcons();
			};
		}
		self.areIconsVisible = true;
		// LK.getSound('uiOpenMenu').play(); // Sound was moved to BuildSpot.down
	};
	self.hideSelectionIcons = function () {
		if (self.selectionIconContainer) {
			self.selectionIconContainer.destroy();
			self.selectionIconContainer = null;
		}
		self.areIconsVisible = false;
		if (currentActiveBuildSpot === self) {
			currentActiveBuildSpot = null;
		}
	};
	self.hideUpgradeMenu = function () {
		if (self.upgradeMenuContainer) {
			self.upgradeMenuContainer.destroy();
			self.upgradeMenuContainer = null;
		}
		// Destroy range indicators if they exist
		if (self.currentRangeIndicator) {
			self.currentRangeIndicator.destroy();
			self.currentRangeIndicator = null;
		}
		if (self.nextRangeIndicator) {
			self.nextRangeIndicator.destroy();
			self.nextRangeIndicator = null;
		}
		self.isUpgradeMenuVisible = false;
		if (currentActiveBuildSpot === self) {
			currentActiveBuildSpot = null;
		}
	};
	self.showTowerActionIcons = function (towerObject) {
		if (!towerObject || !towerObject.towerType) {
			return;
		}
		// Create container for action icons
		self.actionIconContainer = new Container();
		self.actionIconContainer.x = self.x;
		self.actionIconContainer.y = self.y;
		// Add to the same parent as the BuildSpot
		if (self.parent) {
			self.parent.addChild(self.actionIconContainer);
		} else {
			game.addChild(self.actionIconContainer);
		}
		// Get tower data
		var towerTypeKey = towerObject.towerType;
		var currentLevel = towerObject.currentLevel;
		var towerInfo = TOWER_DATA[towerTypeKey];
		var currentLevelData = towerInfo.levels[currentLevel];
		var nextLevelData = towerInfo.levels[currentLevel + 1];
		var isMaxLevel = !nextLevelData;
		// Create a range indicator to show tower's attack range
		self.rangeIndicator = createRangeIndicator(self.x, self.y, currentLevelData.range, self.parent);
		// Position offsets for the icons
		var upgradeIconOffsetX = -110;
		var upgradeIconOffsetY = -110;
		var sellIconOffsetX = 110;
		var sellIconOffsetY = -110;
		// Calculate total tower cost for sell value
		var totalTowerCost = 0;
		for (var i = 0; i <= currentLevel; i++) {
			totalTowerCost += towerInfo.levels[i].cost;
		}
		var sellValue = Math.floor(totalTowerCost * 0.5); // 50% refund
		// Upgrade Icon (if upgradable)
		if (!isMaxLevel) {
			// Create upgrade icon using the next level's asset
			var upgradeIconAsset = towerInfo.levels[currentLevel + 1].asset;
			var upgradeIcon = self.actionIconContainer.attachAsset(upgradeIconAsset, {
				anchorX: 0.5,
				anchorY: 0.5,
				scaleX: 1.0,
				scaleY: 1.0
			});
			upgradeIcon.x = upgradeIconOffsetX;
			upgradeIcon.y = upgradeIconOffsetY;
			// Add plus indicator
			var plusIcon = self.actionIconContainer.attachAsset('uiButtonPlus', {
				anchorX: 0.5,
				anchorY: 0.5,
				scaleX: 1.5,
				scaleY: 1.5
			});
			plusIcon.x = upgradeIcon.x + 35;
			plusIcon.y = upgradeIcon.y - 35;
			// Add upgrade cost text
			var upgradeCostText = new Text2("$" + nextLevelData.cost, {
				size: 20,
				fill: 0xFFFFFF,
				stroke: 0x000000,
				strokeThickness: 2
			});
			upgradeCostText.anchor.set(0.5, -0.7);
			upgradeCostText.x = upgradeIconOffsetX;
			upgradeCostText.y = upgradeIconOffsetY;
			self.actionIconContainer.addChild(upgradeCostText);
			// Make upgrade icon interactive
			upgradeIcon.interactive = currency >= nextLevelData.cost;
			upgradeIcon.alpha = currency >= nextLevelData.cost ? 1.0 : 0.4;
			upgradeIcon.down = function () {
				self.tower.upgrade();
				self.hideTowerActionIcons();
				// If successfully upgraded and still not at max level, show the action icons again
				if (self.tower && self.tower.currentLevel < TOWER_DATA[self.tower.towerType].levels.length - 1) {
					LK.setTimeout(function () {
						self.showTowerActionIcons(self.tower);
					}, 100);
				}
			};
		} else {
			// Show max level indicator (optional)
			var maxLevelIcon = self.actionIconContainer.attachAsset(currentLevelData.asset, {
				anchorX: 0.5,
				anchorY: 0.5,
				scaleX: 0.8,
				scaleY: 0.8,
				alpha: 0.7
			});
			maxLevelIcon.x = upgradeIconOffsetX;
			maxLevelIcon.y = upgradeIconOffsetY;
			var maxText = new Text2("MAX", {
				size: 18,
				fill: 0xFFD700,
				stroke: 0x000000,
				strokeThickness: 2
			});
			maxText.anchor.set(0.5, 0.5);
			maxText.x = upgradeIconOffsetX;
			maxText.y = upgradeIconOffsetY;
			self.actionIconContainer.addChild(maxText);
		}
		// Sell Icon
		var sellIcon = self.actionIconContainer.attachAsset('iconSell', {
			anchorX: 0.5,
			anchorY: 0.5,
			scaleX: 1.5,
			scaleY: 1.5
		});
		sellIcon.x = sellIconOffsetX;
		sellIcon.y = sellIconOffsetY;
		sellIcon.interactive = true;
		// Add sell value text
		var sellText = new Text2("$" + sellValue, {
			size: 20,
			fill: 0xFFFFFF,
			stroke: 0x000000,
			strokeThickness: 2
		});
		sellText.anchor.set(0.5, -0.7);
		sellText.x = sellIconOffsetX;
		sellText.y = sellIconOffsetY;
		self.actionIconContainer.addChild(sellText);
		// Make sell icon interactive
		sellIcon.down = function () {
			self.confirmSellTower(towerObject);
		};
		// Mark as visible
		self.areActionIconsVisible = true;
		LK.getSound('uiOpenMenu').play();
	};
	self.hideTowerActionIcons = function () {
		if (self.actionIconContainer) {
			self.actionIconContainer.destroy();
			self.actionIconContainer = null;
		}
		// Destroy range indicator if it exists
		if (self.rangeIndicator) {
			self.rangeIndicator.destroy();
			self.rangeIndicator = null;
		}
		self.areActionIconsVisible = false;
		if (currentActiveBuildSpot === self) {
			currentActiveBuildSpot = null;
		}
	};
	self.confirmSellTower = function (towerObject) {
		// First, hide action icons
		self.hideTowerActionIcons();
		// Create a confirmation UI
		var confirmContainer = new Container();
		confirmContainer.x = self.x;
		confirmContainer.y = self.y - 150;
		if (self.parent) {
			self.parent.addChild(confirmContainer);
		} else {
			game.addChild(confirmContainer);
		}
		// Calculate sell value
		var towerTypeKey = towerObject.towerType;
		var currentLevel = towerObject.currentLevel;
		var totalTowerCost = 0;
		for (var i = 0; i <= currentLevel; i++) {
			totalTowerCost += TOWER_DATA[towerTypeKey].levels[i].cost;
		}
		var sellValue = Math.floor(totalTowerCost * 0.5); // 50% refund
		// Background
		var confirmBg = confirmContainer.attachAsset('uiButtonBackground', {
			anchorX: 0.5,
			anchorY: 0.5,
			scaleX: 4.0,
			scaleY: 2.5,
			alpha: 0.6
		});
		// Confirmation text
		var confirmText = new Text2("Sell for $" + sellValue + "?", {
			size: 36,
			fill: 0xFFFFFF,
			stroke: 0x000000,
			strokeThickness: 2
		});
		confirmText.anchor.set(0.5, 0);
		confirmText.y = -60;
		confirmContainer.addChild(confirmText);
		// Yes button
		var yesButton = new Text2("YES", {
			size: 40,
			fill: 0x00FF00,
			stroke: 0x000000,
			strokeThickness: 2
		});
		yesButton.anchor.set(0.5, 0);
		yesButton.y = 30;
		yesButton.x = -70;
		yesButton.interactive = true;
		yesButton.down = function () {
			self.sellTower(towerObject, sellValue);
			confirmContainer.destroy();
		};
		confirmContainer.addChild(yesButton);
		// No button
		var noButton = new Text2("NO", {
			size: 40,
			fill: 0xFF0000,
			stroke: 0x000000,
			strokeThickness: 2
		});
		noButton.anchor.set(0.5, 0);
		noButton.y = 30;
		noButton.x = 70;
		noButton.interactive = true;
		noButton.down = function () {
			confirmContainer.destroy();
			// Show tower action icons again
			LK.setTimeout(function () {
				self.showTowerActionIcons(towerObject);
			}, 100);
		};
		confirmContainer.addChild(noButton);
	};
	self.sellTower = function (towerObject, sellValue) {
		// Add refund to currency
		currency += sellValue;
		currencyText.setText("$: " + currency);
		// Play sell sound
		LK.getSound('sellSound').play();
		// Spawn floating text
		spawnFloatingText("SOLD!", self.x, self.y - 50, {
			fill: 0xFFD700
		});
		// Clean up tower
		if (towerObject) {
			towerObject.destroy();
		}
		// Reset BuildSpot
		self.tower = null;
		self.hasTower = false;
		self.graphic.alpha = 0.5;
	};
	self.updateAffordability = function () {
		if (!self.areIconsVisible || !self.selectionIconContainer) {
			return;
		}
		var icons = self.selectionIconContainer.children;
		for (var i = 0; i < icons.length; i++) {
			var iconGraphic = icons[i]; // Now iconGraphic is the direct child
			if (iconGraphic && iconGraphic.towerTypeKey && TOWER_DATA[iconGraphic.towerTypeKey]) {
				var cost = TOWER_DATA[iconGraphic.towerTypeKey].levels[0].cost;
				if (currency < cost) {
					iconGraphic.alpha = 0.4;
					iconGraphic.interactive = false;
				} else {
					iconGraphic.alpha = 1.0;
					iconGraphic.interactive = true;
				}
			}
		}
	};
	self.toggleUpgradeMenu = function () {
		// If upgrade menu is already visible, hide it
		if (self.isUpgradeMenuVisible) {
			self.hideUpgradeMenu();
			return;
		}
		// Hide any other active menus first
		if (currentActiveBuildSpot && currentActiveBuildSpot !== self) {
			if (currentActiveBuildSpot.areIconsVisible) {
				currentActiveBuildSpot.hideSelectionIcons();
			} else if (currentActiveBuildSpot.isUpgradeMenuVisible) {
				currentActiveBuildSpot.hideUpgradeMenu();
			} else if (currentActiveBuildSpot.areActionIconsVisible) {
				currentActiveBuildSpot.hideTowerActionIcons();
			}
		}
		// Set this as the active build spot
		currentActiveBuildSpot = self;
		// Create and show the upgrade menu
		self.showUpgradeMenu(self.tower);
	};
	self.showUpgradeMenu = function (towerObject) {
		if (!towerObject || !towerObject.towerType) {
			return;
		}
		// Create container for upgrade menu
		self.upgradeMenuContainer = new Container();
		self.upgradeMenuContainer.x = self.x;
		self.upgradeMenuContainer.y = self.y - 150; // Position above the tower
		// Add to the same parent as the BuildSpot
		if (self.parent) {
			self.parent.addChild(self.upgradeMenuContainer);
		} else {
			game.addChild(self.upgradeMenuContainer);
		}
		// Get tower data
		var towerTypeKey = towerObject.towerType;
		var currentLevel = towerObject.currentLevel;
		var towerInfo = TOWER_DATA[towerTypeKey];
		var currentLevelData = towerInfo.levels[currentLevel];
		var nextLevelData = towerInfo.levels[currentLevel + 1];
		var isMaxLevel = !nextLevelData;
		// Create range indicator for current level
		self.currentRangeIndicator = createRangeIndicator(self.x, self.y, currentLevelData.range, self.parent);
		// If there's a next level, show its range too with a different appearance
		if (!isMaxLevel) {
			self.nextRangeIndicator = createRangeIndicator(self.x, self.y, nextLevelData.range, self.parent);
			// Make the next level range indicator more distinct
			if (self.nextRangeIndicator.children && self.nextRangeIndicator.children.length >= 2) {
				self.nextRangeIndicator.children[0].tint = 0x00FF00; // Green tint for the fill
				self.nextRangeIndicator.children[1].tint = 0x00FF00; // Green tint for the border
			}
		}
		// Create background
		var menuBg = self.upgradeMenuContainer.attachAsset('uiButtonBackground', {
			anchorX: 0.5,
			anchorY: 0.5,
			scaleX: 3,
			scaleY: 3
		});
		// Tower name and level
		var titleText = new Text2(towerInfo.name + " - Level " + (currentLevel + 1), {
			size: 24,
			fill: 0xFFFFFF,
			stroke: 0x000000,
			strokeThickness: 2
		});
		titleText.anchor.set(0.5, 0);
		titleText.y = -120;
		self.upgradeMenuContainer.addChild(titleText);
		// If there's a next level available
		if (!isMaxLevel) {
			// Upgrade cost
			var costText = new Text2("Upgrade Cost: $" + nextLevelData.cost, {
				size: 20,
				fill: 0xFFFFFF,
				stroke: 0x000000,
				strokeThickness: 2
			});
			costText.anchor.set(0.5, 0);
			costText.y = -85;
			self.upgradeMenuContainer.addChild(costText);
			// Stat changes
			var statsY = -55;
			var statsGap = 25;
			// Add stat comparisons based on tower type
			if (towerTypeKey === 'stapler') {
				// Damage
				var damageText = new Text2("Damage: " + currentLevelData.damage + " → " + nextLevelData.damage, {
					size: 18,
					fill: 0xFFFFFF
				});
				damageText.anchor.set(0.5, 0);
				damageText.y = statsY;
				self.upgradeMenuContainer.addChild(damageText);
				// Range
				var rangeText = new Text2("Range: " + currentLevelData.range + " → " + nextLevelData.range, {
					size: 18,
					fill: 0xFFFFFF
				});
				rangeText.anchor.set(0.5, 0);
				rangeText.y = statsY + statsGap;
				self.upgradeMenuContainer.addChild(rangeText);
				// Fire Rate
				var fireRateText = new Text2("Fire Rate: " + (60 / currentLevelData.fireRate).toFixed(1) + " → " + (60 / nextLevelData.fireRate).toFixed(1), {
					size: 18,
					fill: 0xFFFFFF
				});
				fireRateText.anchor.set(0.5, 0);
				fireRateText.y = statsY + statsGap * 2;
				self.upgradeMenuContainer.addChild(fireRateText);
			} else if (towerTypeKey === 'blocker') {
				// Slow Factor (convert to percentage for clarity)
				var slowText = new Text2("Slow: " + (1 - currentLevelData.slowFactor) * 100 + "% → " + (1 - nextLevelData.slowFactor) * 100 + "%", {
					size: 18,
					fill: 0xFFFFFF
				});
				slowText.anchor.set(0.5, 0);
				slowText.y = statsY;
				self.upgradeMenuContainer.addChild(slowText);
				// Range
				var rangeText = new Text2("Range: " + currentLevelData.range + " → " + nextLevelData.range, {
					size: 18,
					fill: 0xFFFFFF
				});
				rangeText.anchor.set(0.5, 0);
				rangeText.y = statsY + statsGap;
				self.upgradeMenuContainer.addChild(rangeText);
			}
			// Upgrade button
			var upgradeButton = new Text2("UPGRADE", {
				size: 28,
				fill: currency >= nextLevelData.cost ? 0x00FF00 : 0xFF0000,
				stroke: 0x000000,
				strokeThickness: 2
			});
			upgradeButton.anchor.set(0.5, 0);
			upgradeButton.y = 30;
			upgradeButton.interactive = currency >= nextLevelData.cost;
			upgradeButton.down = function () {
				self.tower.upgrade();
			};
			self.upgradeMenuContainer.addChild(upgradeButton);
		} else {
			// Max level text
			var maxLevelText = new Text2("MAX LEVEL REACHED", {
				size: 24,
				fill: 0xFFD700,
				// Gold color
				stroke: 0x000000,
				strokeThickness: 2
			});
			maxLevelText.anchor.set(0.5, 0);
			maxLevelText.y = -50;
			self.upgradeMenuContainer.addChild(maxLevelText);
		}
		// Sell button (optional)
		var sellButton = new Text2("SELL", {
			size: 24,
			fill: 0xFF9999,
			stroke: 0x000000,
			strokeThickness: 2
		});
		sellButton.anchor.set(0.5, 0);
		sellButton.y = 70;
		sellButton.interactive = true;
		sellButton.down = function () {
			// Calculate total value of tower for refund
			var totalTowerCost = 0;
			for (var i = 0; i <= currentLevel; i++) {
				totalTowerCost += TOWER_DATA[towerTypeKey].levels[i].cost;
			}
			var sellValue = Math.floor(totalTowerCost * 0.5); // 50% refund
			// Add refund to currency
			currency += sellValue;
			currencyText.setText("$: " + currency);
			spawnFloatingText("Sold for $" + sellValue, self.x, self.y - 50, {
				fill: 0xFFD700
			});
			LK.getSound('sellSound').play();
			self.tower.destroy();
			self.tower = null;
			self.hasTower = false;
			self.graphic.alpha = 0.5; // Reset buildspot opacity
			self.hideUpgradeMenu();
		};
		self.upgradeMenuContainer.addChild(sellButton);
		// Play sound when opening menu
		LK.getSound('uiOpenMenu').play();
		// Mark menu as visible
		self.isUpgradeMenuVisible = true;
	};
	self.buildSelectedTower = function (towerTypeKey) {
		if (self.hasTower || !TOWER_DATA[towerTypeKey]) {
			return;
		}
		var towerLevelData = TOWER_DATA[towerTypeKey].levels[0];
		if (currency < towerLevelData.cost) {
			return;
		}
		currency -= towerLevelData.cost;
		currencyText.setText("$: " + currency);
		var newTower;
		if (towerTypeKey === 'stapler') {
			newTower = new StaplerTower();
		} else if (towerTypeKey === 'blocker') {
			newTower = new BureaucracyBlockerTower();
		} else if (towerTypeKey === 'laserCat') {
			newTower = new LaserCatPerch();
		} else if (towerTypeKey === 'rickroller') {
			newTower = new RickrollerTower();
			// Play placement sound
			LK.getSound('sfxRickrollerPlace').play();
		} else if (towerTypeKey === 'thisIsFine') {
			newTower = new ThisIsFinePit();
			// Play match strike sound when placing the fire pit
			LK.getSound('sfxThisIsFinePlaceMatch').play();
			// Start gentle fire sound (looping, low volume initially)
			LK.getSound('sfxThisIsFineFireGentle').play();
		} else if (towerTypeKey === 'restruct') {
			newTower = new RestructuringSpecialist();
		}
		// No need for special newTower.init(0) call - constructor handles initialization
		// else if (towerTypeKey === 'placeholder') { /* Do nothing or build a dummy */ return; }
		if (newTower) {
			// The tower's constructor now calls initializeTowerFromData(self, type, 0)
			newTower.x = 0; // Place tower at BuildSpot's origin (local to BuildSpot)
			newTower.y = 0;
			self.addChild(newTower); // Tower becomes child of BuildSpot
			self.tower = newTower;
			self.hasTower = true;
			self.graphic.alpha = 0.1; // Dim the build spot graphic itself
			var buildSfx = TOWER_DATA[towerTypeKey].buildSfx || 'uiSelectTower'; // Fallback
			// Ensure these sounds exist: 'buildStapler', 'buildBlocker'
			// LK.getSound(buildSfx).play(); // Play specific build sound
			// Floating text relative to build spot in world space
			spawnFloatingText(TOWER_DATA[towerTypeKey].name + " BUILT!", self.x, self.y - self.graphic.height / 2, {
				fill: 0x00FF00
			});
			// Update affordability for any other spot's menu that might be open (shouldn't be with current logic)
			if (currentActiveBuildSpot && currentActiveBuildSpot !== self) {
				currentActiveBuildSpot.updateAffordability();
			}
		}
		// Icons are hidden by the icon's down handler OR by game.down clicking elsewhere
	};
	self.down = function () {
		// This is the click on the BuildSpot graphic itself
		if (self.hasTower) {
			// If action icons are already visible, clicking again should close them
			if (self.areActionIconsVisible) {
				self.hideTowerActionIcons();
			} else {
				// Hide any other open menus
				if (currentActiveBuildSpot && currentActiveBuildSpot !== self) {
					if (currentActiveBuildSpot.areIconsVisible) {
						currentActiveBuildSpot.hideSelectionIcons();
					} else if (currentActiveBuildSpot.isUpgradeMenuVisible) {
						currentActiveBuildSpot.hideUpgradeMenu();
					} else if (currentActiveBuildSpot.areActionIconsVisible) {
						currentActiveBuildSpot.hideTowerActionIcons();
					}
				}
				// Set this as the active build spot
				currentActiveBuildSpot = self;
				// Show tower action icons
				LK.getSound('uiOpenMenu').play();
				self.showTowerActionIcons(self.tower);
			}
			return;
		}
		// If this spot's icons are already visible, clicking it again should close them.
		if (self.areIconsVisible) {
			self.hideSelectionIcons();
		} else {
			// If another spot's icons are visible, hide them first.
			if (currentActiveBuildSpot && currentActiveBuildSpot !== self) {
				currentActiveBuildSpot.hideSelectionIcons();
			}
			LK.getSound('uiOpenMenu').play(); // Play sound when opening
			self.showSelectionIcons();
		}
	};
	return self;
});
// --- MODIFY BureaucracyBlockerTower ---
var BureaucracyBlockerTower = Container.expand(function () {
	var self = Container.call(this);
	// --- MODIFIED: No graphic initialization in constructor ---
	self.enemiesSlowed = [];
	// init method removed - functionality moved to constructor and initializeTowerFromData
	self.clearAllSlows = function () {
		for (var i = 0; i < self.enemiesSlowed.length; i++) {
			var enemy = self.enemiesSlowed[i];
			if (enemy && enemy.parent && enemy.isSlowedByBlocker === self) {
				enemy.speed = enemy.originalSpeed;
				enemy.isSlowedByBlocker = null;
				if (enemy.graphic) {
					enemy.graphic.tint = 0xFFFFFF;
				}
			}
		}
		self.enemiesSlowed = [];
	};
	self.update = function () {
		var buildSpot = self.parent;
		if (!buildSpot || !buildSpot.parent) {
			return;
		}
		var levelContainer = buildSpot.parent;
		var towerGraphicGlobalCenter = self.graphic.toGlobal({
			x: 0,
			y: 0
		});
		var towerCenterInGameSpace = game.toLocal(towerGraphicGlobalCenter);
		var newlySlowedThisFrame = [];
		for (var i = 0; i < enemies.length; i++) {
			var enemy = enemies[i];
			if (!enemy || !enemy.parent) {
				continue;
			} // Skip if enemy is already gone
			var dx = enemy.x - towerCenterInGameSpace.x;
			var dy = enemy.y - towerCenterInGameSpace.y;
			var distanceSq = dx * dx + dy * dy;
			if (distanceSq < self.range * self.range) {
				// Enemy is in range
				if (!enemy.isSlowedByBlocker) {
					// Check a custom flag
					enemy.originalSpeed = enemy.speed; // Store original speed
					enemy.speed *= self.slowFactor;
					enemy.isSlowedByBlocker = self; // Mark who slowed it
					// Optional: Visual effect on enemy
					if (enemy.graphic) {
						enemy.graphic.tint = 0xAAAAFF;
					} // Light blue tint
				}
				newlySlowedThisFrame.push(enemy);
			}
		}
		// Check enemies that were slowed last frame but might be out of range now
		for (var i = self.enemiesSlowed.length - 1; i >= 0; i--) {
			var previouslySlowedEnemy = self.enemiesSlowed[i];
			if (!previouslySlowedEnemy || !previouslySlowedEnemy.parent || newlySlowedThisFrame.indexOf(previouslySlowedEnemy) === -1) {
				// Enemy is gone or no longer in range by this tower
				if (previouslySlowedEnemy && previouslySlowedEnemy.isSlowedByBlocker === self) {
					// Only unslow if WE slowed it
					previouslySlowedEnemy.speed = previouslySlowedEnemy.originalSpeed;
					previouslySlowedEnemy.isSlowedByBlocker = null;
					if (previouslySlowedEnemy.graphic) {
						previouslySlowedEnemy.graphic.tint = 0xFFFFFF;
					} // Reset tint
				}
				self.enemiesSlowed.splice(i, 1);
			}
		}
		self.enemiesSlowed = newlySlowedThisFrame; // Update the list of currently slowed enemies
	};
	// When tower is destroyed, make sure to unslow any enemies it was affecting
	var originalDestroy = self.destroy;
	self.destroy = function () {
		for (var i = 0; i < self.enemiesSlowed.length; i++) {
			var enemy = self.enemiesSlowed[i];
			if (enemy && enemy.parent && enemy.isSlowedByBlocker === self) {
				enemy.speed = enemy.originalSpeed;
				enemy.isSlowedByBlocker = null;
				if (enemy.graphic) {
					enemy.graphic.tint = 0xFFFFFF;
				}
			}
		}
		self.enemiesSlowed = [];
		if (originalDestroy) {
			originalDestroy.call(self);
		} else if (self.parent) {
			self.parent.removeChild(self);
		} // Basic destroy
	};
	// Initialize tower with level 0 stats and graphics
	initializeTowerFromData(self, 'blocker', 0); // Set initial stats & correct L0 asset
	return self;
});
var DogeAutoProjectile = Container.expand(function () {
	var self = Container.call(this);
	self.graphic = self.attachAsset('basicAttackProjectile', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.speed = 15;
	self.target = null;
	self.damage = 0; // Will be set by DogeHero when creating projectile
	self.duration = 20; // frames, for self-destruction if target is lost
	self.update = function () {
		// Decrement duration
		self.duration -= gameSpeedMultiplier;
		if (self.duration <= 0) {
			self.destroy();
			return;
		}
		// If target is gone or not in game anymore
		if (!self.target || !self.target.parent) {
			self.alpha -= 0.1 * gameSpeedMultiplier;
			if (self.alpha <= 0) {
				self.destroy();
			}
			return;
		}
		// Move towards target
		var dx = self.target.x - self.x;
		var dy = self.target.y - self.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		// If very close to target, destroy
		if (distance < self.speed * gameSpeedMultiplier || distance < self.target.graphic.width / 2) {
			// Apply damage when hitting the target
			if (self.target && self.target.parent) {
				self.target.takeDamage(self.damage);
			}
			self.destroy();
			return;
		}
		// Move towards target
		dx = dx / distance * self.speed * gameSpeedMultiplier;
		dy = dy / distance * self.speed * gameSpeedMultiplier;
		self.x += dx;
		self.y += dy;
	};
	return self;
});
var DogeCoin = Container.expand(function (spawnX, spawnY, value) {
	var self = Container.call(this);
	// Initialize coin properties
	self.graphic = self.attachAsset('dogeCoin', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.x = spawnX;
	self.y = spawnY;
	self.value = value || 1; // Default to 1 if no value passed
	self.isOnGround = false;
	self.isBeingCollected = false;
	self.spinSpeed = 0.1; // Radians per frame for spinning
	self.collectionRadius = 300; // How close Doge needs to be
	self.lifeTime = 1500; // Frames before it disappears if not collected (25s @ 60fps with gameSpeedMultiplier = 1.0)
	// Initial scatter animation
	var scatterAngle = Math.random() * Math.PI * 2;
	var scatterDistance = 20 + Math.random() * 30;
	var targetX = self.x + Math.cos(scatterAngle) * scatterDistance;
	var targetY = self.y + Math.sin(scatterAngle) * scatterDistance;
	// Start with smaller scale and grow to normal size
	self.graphic.scale.set(0.5);
	// Animate the coin to scatter position and grow to normal size
	tween(self, {
		x: targetX,
		y: targetY
	}, {
		duration: 300 * gameSpeedMultiplier,
		easing: tween.quadOut,
		onFinish: function onFinish() {
			self.isOnGround = true;
		}
	});
	tween(self.graphic.scale, {
		x: 1.0,
		y: 1.0
	}, {
		duration: 300 * gameSpeedMultiplier,
		easing: tween.quadOut
	});
	// Update method for coin behavior
	self.update = function () {
		self.lifeTime -= gameSpeedMultiplier;
		// Destroy if lifetime expires and not being collected
		if (self.lifeTime <= 0 && !self.isBeingCollected) {
			self.destroy();
			return;
		}
		// Skip other updates if being collected
		if (self.isBeingCollected) {
			return;
		}
		// Spin when on ground
		if (self.isOnGround) {
			self.graphic.rotation += self.spinSpeed * gameSpeedMultiplier;
		}
		// Check if Doge is close enough to collect
		if (self.isOnGround && doge && doge.parent) {
			var dx = doge.x - self.x;
			var dy = doge.y - self.y;
			if (dx * dx + dy * dy < self.collectionRadius * self.collectionRadius) {
				self.collect();
			}
		}
	};
	// Collect method when Doge picks up the coin
	self.collect = function () {
		if (self.isBeingCollected) {
			return;
		}
		self.isBeingCollected = true;
		// Update currency and UI
		currency += self.value;
		currencyText.setText("$: " + currency);
		// Show floating text
		spawnFloatingText("+" + self.value + "$", self.x, self.y - 20, {
			fill: 0xFFFF00,
			velocityY: -2
		});
		// Get target position for animation
		var targetUiGlobal = currencyText.toGlobal({
			x: currencyText.width / 2,
			y: currencyText.height / 2
		});
		var targetUiInGame = game.toLocal(targetUiGlobal);
		// Animate coin flying to the UI
		tween(self, {
			x: targetUiInGame.x,
			y: targetUiInGame.y,
			alpha: 0.5
		}, {
			duration: 500 * gameSpeedMultiplier,
			easing: tween.quadIn,
			onFinish: function onFinish() {
				self.destroy();
			}
		});
		// Scale graphic separately since nested properties need their own tween
		tween(self.graphic.scale, {
			x: 0.2,
			y: 0.2
		}, {
			duration: 500 * gameSpeedMultiplier,
			easing: tween.quadIn
		});
	};
	return self;
});
// DogeHero - Now includes auto-attack and manual bark ability logic
var DogeHero = Container.expand(function () {
	var self = Container.call(this);
	self.graphic = self.attachAsset('dogeHero', {
		anchorX: 0.5,
		anchorY: 0.5
	}); // Expose graphic if needed for hit check
	self.width = self.graphic.width; // Store size for hit checks
	self.height = self.graphic.height;
	self.speed = 5;
	self.targetX = self.x;
	self.targetY = self.y;
	// Auto Attack Stats
	self.autoAttackRange = 450; // Increased from 280
	self.autoAttackDamage = 1; // Decreased from 2
	self.autoAttackCooldownTime = 45;
	self.currentAutoAttackCooldown = 0;
	// Manual Bark Ability Stats
	self.manualBarkCooldownTime = 300;
	self.currentManualBarkCooldown = 0;
	self.update = function () {
		// Movement
		var dx = self.targetX - self.x;
		var dy = self.targetY - self.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		if (distance > self.speed) {
			dx = dx / distance * self.speed * gameSpeedMultiplier;
			dy = dy / distance * self.speed * gameSpeedMultiplier;
			self.x += dx;
			self.y += dy;
		} else if (distance > 0) {
			self.x = self.targetX;
			self.y = self.targetY;
		}
		// Cooldowns
		if (self.currentAutoAttackCooldown > 0) {
			self.currentAutoAttackCooldown -= gameSpeedMultiplier;
		}
		if (self.currentManualBarkCooldown > 0) {
			self.currentManualBarkCooldown -= gameSpeedMultiplier;
		}
		// Auto Attack Logic
		if (self.currentAutoAttackCooldown <= 0) {
			var closestEnemy = null;
			var minDistanceSq = self.autoAttackRange * self.autoAttackRange;
			for (var i = 0; i < enemies.length; i++) {
				var enemy = enemies[i];
				var ex = enemy.x - self.x;
				var ey = enemy.y - self.y;
				var distSq = ex * ex + ey * ey;
				if (distSq < minDistanceSq) {
					minDistanceSq = distSq;
					closestEnemy = enemy;
				}
			}
			if (closestEnemy) {
				// Play sound and reset cooldown
				LK.getSound('dogeAutoAttack').play();
				self.currentAutoAttackCooldown = self.autoAttackCooldownTime;
				// Create projectile that will handle damage application
				var projectile = new DogeAutoProjectile();
				projectile.x = self.x;
				projectile.y = self.y;
				projectile.target = closestEnemy;
				projectile.damage = self.autoAttackDamage; // Pass damage value to projectile
				game.addChild(projectile);
			}
		}
	};
	self.setTarget = function (x, y) {
		// Check if we're trying to target a BuildSpot or any of its menus
		var isClickingUI = false;
		// Skip movement if there's any active BuildSpot with open menus
		if (currentActiveBuildSpot) {
			isClickingUI = true;
		}
		// Check if clicked on any BuildSpot
		if (level && level.buildSpots && !isClickingUI) {
			for (var i = 0; i < level.buildSpots.length; i++) {
				var spot = level.buildSpots[i];
				// If we passed the graphic check in game.down 
				// but still reached setTarget, check again
				var dx = x - spot.x;
				var dy = y - spot.y;
				var distSq = dx * dx + dy * dy;
				var hitRadius = 75; // Half of the 150px BuildSpot width
				if (distSq <= hitRadius * hitRadius) {
					isClickingUI = true;
					break;
				}
			}
		}
		// Only move if not clicking UI
		if (!isClickingUI) {
			self.targetX = x;
			self.targetY = y;
		}
	};
	self.manualBark = function () {
		if (self.currentManualBarkCooldown <= 0) {
			var wave = new BarkWave();
			wave.x = self.x;
			wave.y = self.y;
			game.addChild(wave);
			LK.getSound('dogeBark').play();
			self.currentManualBarkCooldown = self.manualBarkCooldownTime;
			return true;
		}
		return false;
	};
	return self;
});
// Enemy class remains largely the same
var Enemy = Container.expand(function () {
	var self = Container.call(this);
	self.walkFrames = ['enemyPaper', 'enemyPaper_walk_1', 'enemyPaper_walk_2']; // Animation frames
	self.currentAnimFrame = 0;
	self.animationSpeed = 15; // Increased from 10 to slow animation further
	self.animationCounter = 0;
	self.graphic = self.attachAsset(self.walkFrames[0], {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.health = 6;
	self.speed = 2;
	self.value = 10; // Currency earned when killed
	self.currentPathIndex = 0;
	self.update = function () {
		// Check if pathPoints is loaded and valid
		if (!pathPoints || pathPoints.length === 0) {
			return;
		}
		if (self.currentPathIndex < pathPoints.length) {
			var target = pathPoints[self.currentPathIndex];
			if (!target) {
				// Safety check
				self.currentPathIndex++;
				return;
			}
			var dx = target.x - self.x;
			var dy = target.y - self.y;
			var distance = Math.sqrt(dx * dx + dy * dy);
			// Use a slightly larger threshold for path progression
			if (distance < self.speed * 1.5) {
				// Adjusted threshold
				self.currentPathIndex++;
				// Check if enemy reached the goal
				if (self.currentPathIndex >= pathPoints.length) {
					playerLives--;
					livesText.setText("Lives: " + playerLives);
					LK.getSound('enemyReachGoal').play();
					if (playerLives <= 0) {
						// Game over
						if (LK.getScore() > storage.highScore) {
							storage.highScore = LK.getScore();
						}
						LK.showGameOver();
					}
					self.destroy();
					return;
				}
			} else {
				// Move towards the target point
				dx = dx / distance * self.speed * gameSpeedMultiplier;
				dy = dy / distance * self.speed * gameSpeedMultiplier;
				self.x += dx;
				self.y += dy;
			}
		} else {
			// If somehow past the end of path but not destroyed, remove it
			console.log("Enemy past end of path, destroying.");
			self.destroy();
		}
		// --- Animation Logic ---
		if (self.walkFrames && self.walkFrames.length > 1) {
			// Only animate if there's more than one frame
			self.animationCounter += gameSpeedMultiplier; // Respect game speed
			if (self.animationCounter >= self.animationSpeed) {
				self.animationCounter = 0;
				self.currentAnimFrame = (self.currentAnimFrame + 1) % self.walkFrames.length;
				// Replace the graphic with the new texture by getting a fresh asset
				var newAsset = self.walkFrames[self.currentAnimFrame];
				if (self.graphic && self.graphic.parent) {
					self.graphic.parent.removeChild(self.graphic);
					self.graphic = self.attachAsset(newAsset, {
						anchorX: 0.5,
						anchorY: 0.5,
						alpha: 1
					});
				}
			}
		}
		// --- End Animation Logic ---
	};
	self.takeDamage = function (amount) {
		self.health -= amount;
		// Flash red when taking damage
		LK.effects.flashObject(self, 0xff0000, 200);
		if (self.health <= 0 && self.parent) {
			// Added check for self.parent before accessing currency
			// Determine number of coins to drop based on enemy value
			var numCoins = Math.ceil(self.value / 5); // 1 coin per 5 value, min 1
			if (numCoins < 1) {
				numCoins = 1;
			}
			// Spawn multiple coins
			for (var i = 0; i < numCoins; i++) {
				var coin = new DogeCoin(self.x, self.y, Math.floor(self.value / numCoins));
				if (game.coinLayer) {
					game.coinLayer.addChild(coin);
				} else {
					coinLayer.addChild(coin);
				}
			}
			// Score still goes up immediately
			LK.setScore(LK.getScore() + self.value);
			scoreText.setText("Score: " + LK.getScore());
			LK.getSound('enemyDeath').play();
			self.destroy();
		}
	};
	return self;
});
// GameLevel class remains the same
var GameLevel = Container.expand(function () {
	var self = Container.call(this);
	var pathGraphics = []; // Store path visuals
	var buildSpotGraphics = []; // Store build spot visuals
	self.createPath = function (pathData) {
		// Clear previous path graphics
		pathGraphics.forEach(function (tile) {
			tile.destroy();
		});
		pathGraphics = [];
		// Assume pathData is the pathPoints array
		for (var i = 0; i < pathData.length - 1; i++) {
			var start = pathData[i];
			var end = pathData[i + 1];
			if (!start || !end) {
				continue;
			} // Safety check
			// Calculate direction and distance
			var dx = end.x - start.x;
			var dy = end.y - start.y;
			var distance = Math.sqrt(dx * dx + dy * dy);
			// Adjust tile spacing slightly
			var steps = Math.ceil(distance / 90); // Slightly closer tiles
			for (var j = 0; j < steps; j++) {
				var ratio = j / steps;
				var x = start.x + dx * ratio;
				var y = start.y + dy * ratio;
				var tile = LK.getAsset('pathTile', {
					x: x,
					y: y,
					alpha: 0.3,
					// Make path fainter
					anchorX: 0.5,
					anchorY: 0.5
				});
				self.addChild(tile);
				pathGraphics.push(tile); // Store reference
			}
		}
	};
	self.createBuildSpots = function (spotsData) {
		// Clear previous build spots
		buildSpotGraphics.forEach(function (spot) {
			spot.destroy();
		});
		buildSpotGraphics = [];
		self.buildSpots = []; // Clear the logical array too
		for (var i = 0; i < spotsData.length; i++) {
			if (!spotsData[i]) {
				continue;
			} // Safety check
			var spot = new BuildSpot();
			spot.x = spotsData[i].x;
			spot.y = spotsData[i].y;
			self.addChild(spot);
			self.buildSpots.push(spot); // Store logical spot
			buildSpotGraphics.push(spot); // Store graphical spot
		}
	};
	return self;
});
// Goal class remains the same
var Goal = Container.expand(function () {
	var self = Container.call(this);
	var graphic = self.attachAsset('goal', {
		anchorX: 0.5,
		anchorY: 0.5,
		alpha: 0.6
	});
	return self;
});
var InternOnCoffeeRun = Container.expand(function () {
	var self = Container.call(this);
	self.walkFrames = ['enemyIntern', 'enemyIntern_walk_1', 'enemyIntern_walk_2']; // Animation frames
	self.currentAnimFrame = 0;
	self.animationSpeed = 5; // Faster animation for fast enemy
	self.animationCounter = 0;
	self.graphic = self.attachAsset(self.walkFrames[0], {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.health = 4; // Low health
	self.speed = 4.0; // Fast speed
	self.value = 5; // Low currency reward
	self.isFlying = false;
	self.currentPathIndex = 0;
	self.update = function () {
		// Check if pathPoints is loaded and valid
		if (!pathPoints || pathPoints.length === 0) {
			return;
		}
		if (self.currentPathIndex < pathPoints.length) {
			var target = pathPoints[self.currentPathIndex];
			if (!target) {
				// Safety check
				self.currentPathIndex++;
				return;
			}
			var dx = target.x - self.x;
			var dy = target.y - self.y;
			var distance = Math.sqrt(dx * dx + dy * dy);
			// Use a slightly larger threshold for path progression
			if (distance < self.speed * 1.5) {
				// Adjusted threshold
				self.currentPathIndex++;
				// Check if enemy reached the goal
				if (self.currentPathIndex >= pathPoints.length) {
					playerLives--;
					livesText.setText("Lives: " + playerLives);
					LK.getSound('enemyReachGoal').play();
					if (playerLives <= 0) {
						// Game over
						if (LK.getScore() > storage.highScore) {
							storage.highScore = LK.getScore();
						}
						LK.showGameOver();
					}
					self.destroy();
					return;
				}
			} else {
				// Move towards the target point
				dx = dx / distance * self.speed * gameSpeedMultiplier;
				dy = dy / distance * self.speed * gameSpeedMultiplier;
				self.x += dx;
				self.y += dy;
			}
		} else {
			// If somehow past the end of path but not destroyed, remove it
			console.log("Enemy past end of path, destroying.");
			self.destroy();
		}
		// --- Animation Logic ---
		if (self.walkFrames && self.walkFrames.length > 1) {
			// Only animate if there's more than one frame
			self.animationCounter += gameSpeedMultiplier; // Respect game speed
			if (self.animationCounter >= self.animationSpeed) {
				self.animationCounter = 0;
				self.currentAnimFrame = (self.currentAnimFrame + 1) % self.walkFrames.length;
				var newAssetIdToAttach = self.walkFrames[self.currentAnimFrame];
				if (self.graphic && self.graphic.parent) {
					// Preserve local position if self.graphic is a direct child of self
					var currentLocalX = self.graphic.x;
					var currentLocalY = self.graphic.y;
					self.removeChild(self.graphic); // Or self.graphic.destroy(); if that's more appropriate
					self.graphic = self.attachAsset(newAssetIdToAttach, {
						anchorX: 0.5,
						anchorY: 0.5,
						x: currentLocalX,
						// Restore local x
						y: currentLocalY // Restore local y
					});
				} else if (!self.graphic && self.parent) {
					// If graphic was lost but enemy still exists
					self.graphic = self.attachAsset(newAssetIdToAttach, {
						anchorX: 0.5,
						anchorY: 0.5
					});
				}
			}
		}
		// --- End Animation Logic ---
	};
	self.takeDamage = function (amount) {
		self.health -= amount;
		// Flash red when taking damage
		LK.effects.flashObject(self, 0xff0000, 200);
		if (self.health <= 0 && self.parent) {
			// Added check for self.parent before accessing currency
			// Determine number of coins to drop based on enemy value
			var numCoins = Math.ceil(self.value / 5); // 1 coin per 5 value, min 1
			if (numCoins < 1) {
				numCoins = 1;
			}
			// Spawn multiple coins
			for (var i = 0; i < numCoins; i++) {
				var coin = new DogeCoin(self.x, self.y, Math.floor(self.value / numCoins));
				if (game.coinLayer) {
					game.coinLayer.addChild(coin);
				} else {
					coinLayer.addChild(coin);
				}
			}
			// Score still goes up immediately
			LK.setScore(LK.getScore() + self.value);
			scoreText.setText("Score: " + LK.getScore());
			LK.getSound('enemyDeath').play();
			self.destroy();
		}
	};
	return self;
});
var LaserCatPerch = Container.expand(function () {
	var self = Container.call(this);
	// Initialize the tower with level 0 stats and graphics
	initializeTowerFromData(self, 'laserCat', 0);
	self.activeBeams = []; // Array to store info about current beams {target, beamGraphic, durationTimer, currentDotDamage}
	self.cooldownTimer = 0; // Time until it can look for new targets after all beams finish or max targets reached
	self.update = function () {
		var buildSpot = self.parent;
		if (!buildSpot || !buildSpot.parent) {
			return;
		}
		// Get tower position in game space
		var towerGraphicGlobalCenter = self.graphic.toGlobal({
			x: 0,
			y: 0
		});
		var towerPosInGameSpace = game.toLocal(towerGraphicGlobalCenter);
		// Decrement cooldown timer
		if (self.cooldownTimer > 0) {
			self.cooldownTimer -= 1000 / 60 * gameSpeedMultiplier; // Convert from ms to frames
		}
		// Handle Active Beams
		for (var i = self.activeBeams.length - 1; i >= 0; i--) {
			var beamData = self.activeBeams[i];
			// Check if target is still valid and in range
			if (!beamData.target || !beamData.target.parent) {
				// Target no longer exists
				beamData.beamGraphic.destroy();
				self.activeBeams.splice(i, 1);
				continue;
			}
			// Check if target is out of range
			var dx = beamData.target.x - towerPosInGameSpace.x;
			var dy = beamData.target.y - towerPosInGameSpace.y;
			var distance = Math.sqrt(dx * dx + dy * dy);
			if (distance > self.range) {
				// Target out of range
				beamData.beamGraphic.destroy();
				self.activeBeams.splice(i, 1);
				continue;
			}
			// Decrement beam duration timer
			beamData.durationTimer -= 1000 / 60 * gameSpeedMultiplier;
			// Apply DOT damage at intervals
			beamData.dotTickTimer -= 1000 / 60 * gameSpeedMultiplier;
			if (beamData.dotTickTimer <= 0) {
				// Apply damage
				beamData.target.takeDamage(beamData.currentDotDamage);
				// Ramp up damage for next tick
				beamData.currentDotDamage *= self.dotRampUpFactor;
				// Reset tick timer (damage every 0.5 seconds)
				beamData.dotTickTimer = 500;
			}
			// Update beam visual
			// Position beam at tower position
			beamData.beamGraphic.x = towerPosInGameSpace.x;
			beamData.beamGraphic.y = towerPosInGameSpace.y;
			// Calculate direction and distance
			var targetPosInGameSpace = {
				x: beamData.target.x,
				y: beamData.target.y
			};
			var dx = targetPosInGameSpace.x - towerPosInGameSpace.x;
			var dy = targetPosInGameSpace.y - towerPosInGameSpace.y;
			var distance = Math.sqrt(dx * dx + dy * dy);
			// Adjust beam rotation and height
			beamData.beamGraphic.rotation = Math.atan2(dy, dx) - Math.PI / 2; // Adjust rotation
			beamData.beamGraphic.height = distance; // Stretch beam to reach target
			// Make sure the beam is in the game container (not a child of the tower)
			if (!beamData.beamGraphic.parent) {
				game.addChild(beamData.beamGraphic);
			} else if (beamData.beamGraphic.parent !== game) {
				if (beamData.beamGraphic.parent) {
					beamData.beamGraphic.parent.removeChild(beamData.beamGraphic);
				}
				game.addChild(beamData.beamGraphic);
			}
			// If beam duration is up, destroy it
			if (beamData.durationTimer <= 0) {
				beamData.beamGraphic.destroy();
				self.activeBeams.splice(i, 1);
			}
		}
		// Find New Targets if not on cooldown and not at max beams
		if (self.cooldownTimer <= 0 && self.activeBeams.length < self.numberOfBeams) {
			// Find potential targets in range that aren't already targeted
			var potentialTargets = [];
			for (var i = 0; i < enemies.length; i++) {
				var enemy = enemies[i];
				if (!enemy || !enemy.parent) {
					continue;
				}
				// Check if enemy is in range
				var dx = enemy.x - towerPosInGameSpace.x;
				var dy = enemy.y - towerPosInGameSpace.y;
				var distanceSq = dx * dx + dy * dy;
				if (distanceSq <= self.range * self.range) {
					// Check if enemy is already targeted by an active beam
					var alreadyTargeted = false;
					for (var j = 0; j < self.activeBeams.length; j++) {
						if (self.activeBeams[j].target === enemy) {
							alreadyTargeted = true;
							break;
						}
					}
					if (!alreadyTargeted) {
						potentialTargets.push(enemy);
					}
				}
			}
			// If targets available, target the strongest (highest health)
			if (potentialTargets.length > 0) {
				// Sort by health (highest first)
				potentialTargets.sort(function (a, b) {
					return b.health - a.health;
				});
				// Target the strongest enemy
				var targetEnemy = potentialTargets[0];
				// Create beam graphic
				var beamGfx = LK.getAsset('laserBeam', {
					anchorX: 0.5,
					anchorY: 0 // Anchor at top center
				});
				// Position at tower
				beamGfx.x = towerPosInGameSpace.x;
				beamGfx.y = towerPosInGameSpace.y;
				// Calculate direction and distance to target
				var dx = targetEnemy.x - towerPosInGameSpace.x;
				var dy = targetEnemy.y - towerPosInGameSpace.y;
				var distance = Math.sqrt(dx * dx + dy * dy);
				// Set rotation and height (stretch beam to reach target)
				beamGfx.rotation = Math.atan2(dy, dx) - Math.PI / 2;
				beamGfx.height = distance;
				// Add to game (below enemy layer if possible, or directly to game)
				game.addChild(beamGfx);
				// Apply initial damage
				targetEnemy.takeDamage(self.initialBeamDamage);
				// Play firing sound
				// LK.getSound('sfxLaserCatFireInitialPew').play();
				// Start beam loop sound
				// var beamLoopSound = LK.getSound('sfxLaserCatFireBeamLoop').play();
				// Add to active beams
				self.activeBeams.push({
					target: targetEnemy,
					beamGraphic: beamGfx,
					durationTimer: self.maxBeamDuration,
					currentDotDamage: self.dotDamagePerSecond,
					dotTickTimer: 500 // First tick after 0.5 seconds
				});
				// If at max beams, start cooldown
				if (self.activeBeams.length >= self.numberOfBeams) {
					self.cooldownTimer = self.cooldownBetweenBeams;
				}
			}
		}
		// Targeting hum sound logic
		if (self.activeBeams.length > 0) {
			// Play targeting hum sound if not already playing
			// if (!humSoundPlaying) {
			//    humSoundPlaying = true;
			//    LK.getSound('sfxLaserCatTargetHum').play();
			// }
		} else {
			// Stop hum sound if playing
			// if (humSoundPlaying) {
			//    humSoundPlaying = false;
			//    LK.getSound('sfxLaserCatTargetHum').stop();
			// }
		}
	};
	// Override destroy method to clean up beams
	var originalDestroy = self.destroy;
	self.destroy = function () {
		// Clean up all active beams
		for (var i = 0; i < self.activeBeams.length; i++) {
			if (self.activeBeams[i].beamGraphic) {
				self.activeBeams[i].beamGraphic.destroy();
			}
		}
		// Stop any looping sounds
		// if (humSoundPlaying) {
		//    LK.getSound('sfxLaserCatTargetHum').stop();
		// }
		// Call original destroy
		if (originalDestroy) {
			originalDestroy.call(self);
		} else if (self.parent) {
			self.parent.removeChild(self);
		}
	};
	self.shoot = function (target) {
		// This method is kept for compatibility but not used actively
		// The beam firing logic is handled in update()
	};
	return self;
});
// Range Indicator to visualize tower attack ranges
var RangeIndicator = Container.expand(function (centerX, centerY, radius, parentContainer) {
	var self = Container.call(this);
	// Create container for the indicator
	self.x = centerX;
	self.y = centerY;
	// Since we can't draw circles directly in LK, use a pre-defined circle asset
	// and scale it to match our desired radius
	var rangeCircle = self.attachAsset('centerCircle', {
		anchorX: 0.5,
		anchorY: 0.5,
		alpha: 0.05,
		// Very faint fill
		tint: 0xFFFFFF // White color
	});
	// The centerCircle asset is 100px in diameter, so scale accordingly
	var scaleRatio = radius * 2 / 100;
	rangeCircle.scaleX = scaleRatio;
	rangeCircle.scaleY = scaleRatio;
	// Add a slightly larger circle with higher alpha for the border effect
	var rangeBorder = self.attachAsset('centerCircle', {
		anchorX: 0.5,
		anchorY: 0.5,
		alpha: 0.3,
		// More visible than the fill
		tint: 0xFFFFFF // White color
	});
	// Make border slightly larger
	var borderScaleRatio = scaleRatio * 1.02;
	rangeBorder.scaleX = borderScaleRatio;
	rangeBorder.scaleY = borderScaleRatio;
	// Add to parent container
	if (parentContainer) {
		parentContainer.addChild(self);
	}
	return self;
});
// --- NEW ENEMY: RedTapeWorm ---
var RedTapeWorm = Container.expand(function () {
	var self = Container.call(this);
	// Inherit from Enemy - this copies properties and methods if Enemy is set up for it.
	// If Enemy is not a true prototypal base, we'll redefine common things.
	// For simplicity, let's assume Enemy provides a good base or we'll set manually.
	// Call parent constructor if applicable
	// Override or set specific properties
	self.walkFrames = ['enemyRedTapeWorm', 'enemyRedTapeWorm_walk_1', 'enemyRedTapeWorm_walk_2']; // Animation frames
	self.currentAnimFrame = 0;
	self.animationSpeed = 10; // Slower animation for slow enemy
	self.animationCounter = 0;
	self.graphic = self.attachAsset(self.walkFrames[0], {
		anchorX: 0.5,
		anchorY: 0.5
	}); // Use new asset
	self.health = 30; // High health
	self.speed = 0.75; // Very slow speed
	self.value = 25; // More currency
	// Optional: Custom sound on spawn or movement
	// LK.getSound('tapeStretch').play(); // (Could be spammy if played on update)
	// The base Enemy.update() and Enemy.takeDamage() should work if inherited.
	// If not, you'd copy and paste that logic here, adjusting as needed.
	// For now, assume base Enemy update handles pathing and goal reaching.
	// Custom onDefeat behavior if needed (e.g., spawn smaller tapes - too complex for now)
	self.update = function () {
		// Check if pathPoints is loaded and valid
		if (!pathPoints || pathPoints.length === 0) {
			return;
		}
		if (self.currentPathIndex < pathPoints.length) {
			var target = pathPoints[self.currentPathIndex];
			if (!target) {
				// Safety check
				self.currentPathIndex++;
				return;
			}
			var dx = target.x - self.x;
			var dy = target.y - self.y;
			var distance = Math.sqrt(dx * dx + dy * dy);
			// Use a slightly larger threshold for path progression
			if (distance < self.speed * 1.5) {
				// Adjusted threshold
				self.currentPathIndex++;
				// Check if enemy reached the goal
				if (self.currentPathIndex >= pathPoints.length) {
					playerLives--;
					livesText.setText("Lives: " + playerLives);
					LK.getSound('enemyReachGoal').play();
					if (playerLives <= 0) {
						// Game over
						if (LK.getScore() > storage.highScore) {
							storage.highScore = LK.getScore();
						}
						LK.showGameOver();
					}
					self.destroy();
					return;
				}
			} else {
				// Move towards the target point
				dx = dx / distance * self.speed * gameSpeedMultiplier;
				dy = dy / distance * self.speed * gameSpeedMultiplier;
				self.x += dx;
				self.y += dy;
			}
		} else {
			// If somehow past the end of path but not destroyed, remove it
			console.log("Enemy past end of path, destroying.");
			self.destroy();
		}
		// --- Animation Logic ---
		if (self.walkFrames && self.walkFrames.length > 1) {
			// Only animate if there's more than one frame
			self.animationCounter += gameSpeedMultiplier; // Respect game speed
			if (self.animationCounter >= self.animationSpeed) {
				self.animationCounter = 0;
				self.currentAnimFrame = (self.currentAnimFrame + 1) % self.walkFrames.length;
				var newAssetIdToAttach = self.walkFrames[self.currentAnimFrame];
				if (self.graphic && self.graphic.parent) {
					// Preserve local position if self.graphic is a direct child of self
					var currentLocalX = self.graphic.x;
					var currentLocalY = self.graphic.y;
					self.removeChild(self.graphic); // Or self.graphic.destroy(); if that's more appropriate
					self.graphic = self.attachAsset(newAssetIdToAttach, {
						anchorX: 0.5,
						anchorY: 0.5,
						x: currentLocalX,
						// Restore local x
						y: currentLocalY // Restore local y
					});
				} else if (!self.graphic && self.parent) {
					// If graphic was lost but enemy still exists
					self.graphic = self.attachAsset(newAssetIdToAttach, {
						anchorX: 0.5,
						anchorY: 0.5
					});
				}
			}
		}
		// --- End Animation Logic ---
	};
	self.takeDamage = function (amount) {
		self.health -= amount;
		// Flash red when taking damage
		LK.effects.flashObject(self, 0xff0000, 200);
		if (self.health <= 0 && self.parent) {
			// Added check for self.parent before accessing currency
			// Determine number of coins to drop based on enemy value
			var numCoins = Math.ceil(self.value / 5); // 1 coin per 5 value, min 1
			if (numCoins < 1) {
				numCoins = 1;
			}
			// Spawn multiple coins
			for (var i = 0; i < numCoins; i++) {
				var coin = new DogeCoin(self.x, self.y, Math.floor(self.value / numCoins));
				if (game.coinLayer) {
					game.coinLayer.addChild(coin);
				} else {
					coinLayer.addChild(coin);
				}
			}
			// Score still goes up immediately
			LK.setScore(LK.getScore() + self.value);
			scoreText.setText("Score: " + LK.getScore());
			LK.getSound('enemyDeath').play();
			self.destroy();
		}
	};
	var originalDestroy = self.destroy; // Keep a reference to base destroy
	self.destroy = function () {
		// spawnFloatingText("So Bureaucratic!", self.x, self.y - 50, { fill: 0xFF6666 }); // Example
		originalDestroy.call(self); // Call the original destroy method
	};
	return self;
});
var RestructuringSpecialist = Container.expand(function () {
	var self = Container.call(this);
	// Initialize the tower with level 0 stats and graphics
	initializeTowerFromData(self, 'restruct', 0);
	// Charge properties
	self.currentCharge = 0;
	self.chargeUpTime = 360; // Frames to fully charge
	self.currentTarget = null;
	self.isFiring = false;
	self.chargeVisuals = [];
	self.chargeSoundInstance = null;
	self.chargeSfx = 'sfxRestructCharge';
	self.update = function () {
		// If tower is in the firing animation, don't do anything else
		if (self.isFiring) {
			return;
		}
		// Get tower position in game space
		var buildSpot = self.parent;
		if (!buildSpot || !buildSpot.parent) {
			return;
		}
		var towerGraphicGlobalCenter = self.graphic.toGlobal({
			x: 0,
			y: 0
		});
		var towerPosInGameSpace = game.toLocal(towerGraphicGlobalCenter);
		// Check if current target exists and is still valid
		if (self.currentTarget && self.currentTarget.parent) {
			// Check if target is still in range
			var targetPosInGameSpace = {
				x: self.currentTarget.x,
				y: self.currentTarget.y
			};
			var dx = targetPosInGameSpace.x - towerPosInGameSpace.x;
			var dy = targetPosInGameSpace.y - towerPosInGameSpace.y;
			var distanceSq = dx * dx + dy * dy;
			// If target moved out of range, reset charging
			if (distanceSq > self.range * self.range) {
				self.currentTarget = null;
				self.currentCharge = 0;
				self.clearChargeVisuals();
				self.stopChargeSound();
				return;
			}
			// Continue charging up
			self.currentCharge += gameSpeedMultiplier;
			// Update the charge visuals
			self.updateChargeVisuals(towerPosInGameSpace);
			// Update charge sound
			if (!self.chargeSoundInstance) {
				self.chargeSoundInstance = LK.getSound(self.chargeSfx || 'sfxRestructCharge').play({
					loop: true,
					volume: 0.3
				});
			} else {
				// Optionally increase volume/pitch as charge builds up
				var chargeProgress = Math.min(1.0, self.currentCharge / self.chargeUpTime);
				if (self.chargeSoundInstance.volume) {
					self.chargeSoundInstance.volume = 0.3 + 0.7 * chargeProgress;
				}
			}
			// If fully charged, restructure the enemy
			if (self.currentCharge >= self.chargeUpTime) {
				self.fireRestructure();
			}
		} else {
			// No valid target or target was lost, reset charge
			self.currentCharge = 0;
			self.clearChargeVisuals();
			self.stopChargeSound();
			// Find new target based on priority
			var newTarget = null;
			var maxHealth = 0;
			// Iterate through enemies to find valid targets in range
			for (var i = 0; i < enemies.length; i++) {
				var enemy = enemies[i];
				if (!enemy || !enemy.parent) {
					continue;
				}
				var dx = enemy.x - towerPosInGameSpace.x;
				var dy = enemy.y - towerPosInGameSpace.y;
				var distanceSq = dx * dx + dy * dy;
				if (distanceSq <= self.range * self.range) {
					// If targeting strongest enemies, track the one with highest health
					if (self.targetPriority === 'strongest') {
						if (enemy.health > maxHealth) {
							maxHealth = enemy.health;
							newTarget = enemy;
						}
					} else {
						// Default to first enemy in range if no specific priority
						newTarget = enemy;
						break;
					}
				}
			}
			// If a new target was found, set it
			if (newTarget) {
				self.currentTarget = newTarget;
				self.currentCharge = 0; // Start charging from zero
			}
		}
	};
	self.updateChargeVisuals = function (towerPos) {
		// Initialize charge visuals array if needed
		if (!self.chargeVisuals) {
			self.chargeVisuals = [];
		}
		// Calculate how many visuals to show based on charge progress
		var numVisuals = Math.floor(self.currentCharge / self.chargeUpTime * 5); // Max 5 visuals
		// Add new visuals if needed
		while (self.chargeVisuals.length < numVisuals) {
			// Randomly choose between two visual types
			var visualAsset = Math.random() < 0.5 ? 'flowchartSegment1' : 'flowchartSegment2';
			var v = self.attachAsset(visualAsset, {
				anchorX: 0.5,
				anchorY: 0.5
			});
			self.chargeVisuals.push(v);
		}
		// Remove excess visuals if needed
		while (self.chargeVisuals.length > numVisuals) {
			var v = self.chargeVisuals.pop();
			v.destroy();
		}
		// Update the position of each visual to orbit the tower
		for (var i = 0; i < self.chargeVisuals.length; i++) {
			var v = self.chargeVisuals[i];
			// Calculate orbit position based on charge progress and visual index
			v.x = Math.cos(self.currentCharge * 0.1 + i * Math.PI * 0.4) * 50;
			v.y = Math.sin(self.currentCharge * 0.1 + i * Math.PI * 0.4) * 50;
			// Optional: increase scale or alpha as charge progresses
			var chargeProgress = self.currentCharge / self.chargeUpTime;
			v.alpha = 0.5 + chargeProgress * 0.5;
			v.scale.set(0.8 + chargeProgress * 0.4);
		}
	};
	self.clearChargeVisuals = function () {
		// Destroy all charge visuals
		if (self.chargeVisuals) {
			for (var i = 0; i < self.chargeVisuals.length; i++) {
				self.chargeVisuals[i].destroy();
			}
			self.chargeVisuals = [];
		}
	};
	self.stopChargeSound = function () {
		// Stop the charging sound if it's playing
		if (self.chargeSoundInstance) {
			self.chargeSoundInstance.stop();
			self.chargeSoundInstance = null;
		}
	};
	self.fireRestructure = function () {
		// Exit if no valid target or already firing
		if (!self.currentTarget || !self.currentTarget.parent || self.isFiring) {
			return;
		}
		self.isFiring = true;
		self.stopChargeSound();
		self.clearChargeVisuals();
		// Play launch SFX
		LK.getSound(self.launchSfx || 'sfxRestructLaunchDoge').play();
		// Store reference to target before potentially nulling
		var enemyToRestructure = self.currentTarget;
		var targetPosInGameSpace = {
			x: enemyToRestructure.x,
			y: enemyToRestructure.y
		};
		// Spawn restructure effect on target
		var effect = game.attachAsset(self.effectAsset || 'restructureEffect', {
			anchorX: 0.5,
			anchorY: 0.5,
			x: targetPosInGameSpace.x,
			y: targetPosInGameSpace.y
		});
		// Play impact sound
		LK.getSound(self.impactSfx || 'sfxRestructImpact').play();
		// Apply damage or kill
		if (enemyToRestructure.health <= self.instantKillThreshold) {
			// Instant kill if below threshold
			spawnFloatingText("OPTIMIZED!", enemyToRestructure.x, enemyToRestructure.y, {
				fill: 0x00FFFF
			});
			enemyToRestructure.destroy();
		} else {
			// Otherwise apply damage
			enemyToRestructure.takeDamage(self.damage);
		}
		// Golden Parachute logic (Level 3+)
		if (self.currentLevel >= 2 && self.goldenParachuteDamage > 0 && (!enemyToRestructure.parent || enemyToRestructure.health <= 0)) {
			// If enemy was killed, apply splash damage
			spawnFloatingText("Severance!", targetPosInGameSpace.x, targetPosInGameSpace.y - 30, {
				fill: 0xFFD700
			});
			for (var i = 0; i < enemies.length; i++) {
				var nearbyEnemy = enemies[i];
				if (nearbyEnemy === enemyToRestructure || !nearbyEnemy.parent) {
					continue;
				}
				var dx = nearbyEnemy.x - targetPosInGameSpace.x;
				var dy = nearbyEnemy.y - targetPosInGameSpace.y;
				if (dx * dx + dy * dy < self.goldenParachuteRadius * self.goldenParachuteRadius) {
					nearbyEnemy.takeDamage(self.goldenParachuteDamage);
				}
			}
		}
		// Reset state and clean up
		self.currentCharge = 0;
		self.currentTarget = null;
		// Clean up effect after animation
		LK.setTimeout(function () {
			if (effect && effect.parent) {
				effect.destroy();
			}
			// Clear firing flag after brief delay
			LK.setTimeout(function () {
				self.isFiring = false;
			}, 200 / gameSpeedMultiplier);
		}, 500);
	};
	self.findTarget = function () {
		// This method is preserved for backward compatibility
		// The targeting logic is now handled in update()
	};
	self.restructureEnemy = function () {
		if (!self.targetEnemy || !self.targetEnemy.parent) {
			self.isCharging = false;
			self.chargeLevel = 0;
			return;
		}
		// Create visual effect
		var effect = self.attachAsset('restructureEffect', {
			anchorX: 0.5,
			anchorY: 0.5
		});
		// Destroy effect after animation
		LK.setTimeout(function () {
			if (effect && effect.parent) {
				effect.parent.removeChild(effect);
			}
		}, 500);
		// Give player currency and score for the transformation
		currency += self.targetEnemy.value;
		currencyText.setText("$: " + currency);
		LK.setScore(LK.getScore() + self.targetEnemy.value);
		scoreText.setText("Score: " + LK.getScore());
		// Play effect sound
		LK.getSound('sfxRestructTransformKill').play();
		// Remove the enemy
		self.targetEnemy.destroy();
		// Reset tower state
		self.isCharging = false;
		self.chargeLevel = 0;
		self.targetEnemy = null;
	};
	return self;
});
var RickAstleyProjectile = Container.expand(function (startX, startY, endX, endY, towerOwner) {
	var self = Container.call(this);
	self.graphic = self.attachAsset(towerOwner.popupAsset, {
		anchorX: 0.5,
		anchorY: 0.5,
		alpha: 0.7,
		scaleX: 0.5,
		scaleY: 0.5
	});
	self.x = startX;
	self.y = startY;
	self.targetX = endX;
	self.targetY = endY;
	self.speed = towerOwner.projectileSpeed || 7; // Use tower's speed or default to 7
	self.towerOwner = towerOwner;
	self.hasHitTarget = false;
	self.updateProjectile = function () {
		if (self.hasHitTarget) {
			return;
		}
		// Calculate direction and distance
		var dx = self.targetX - self.x;
		var dy = self.targetY - self.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		// Check if reached target
		if (distance < self.speed * gameSpeedMultiplier) {
			self.hasHitTarget = true;
			self.towerOwner.activateEffectAtLocation(self.targetX, self.targetY);
			self.destroy();
			return;
		}
		// Move towards target
		dx = dx / distance * self.speed * gameSpeedMultiplier;
		dy = dy / distance * self.speed * gameSpeedMultiplier;
		self.x += dx;
		self.y += dy;
	};
	return self;
});
var RickrollerTower = Container.expand(function () {
	var self = Container.call(this);
	// Initialize the tower with level 0 stats and graphics
	initializeTowerFromData(self, 'rickroller', 0);
	self.currentCooldown = 0; // Time in ms until it can fire again
	self.activeProjectiles = []; // To track flying Rick Astleys
	self.activePopups = []; // To keep track of all active Rick popups for dancing
	self.update = function () {
		// Cooldown Management
		if (self.currentCooldown > 0) {
			self.currentCooldown -= 1000 / 60 * gameSpeedMultiplier;
		} else {
			self.findTargetAndFire();
		}
		// Update Active Projectiles
		for (var i = self.activeProjectiles.length - 1; i >= 0; i--) {
			var rickProjectile = self.activeProjectiles[i];
			rickProjectile.updateProjectile();
			if (rickProjectile.hasHitTarget || !rickProjectile.parent) {
				self.activeProjectiles.splice(i, 1);
			}
		}
		// Update Rick Astley Dance Animations
		for (var i = self.activePopups.length - 1; i >= 0; i--) {
			var p = self.activePopups[i];
			if (!p || !p.parent) {
				// If popup was destroyed elsewhere
				self.activePopups.splice(i, 1);
				continue;
			}
			if (p.isDancing) {
				self.updateRickDance(p); // Call method to update dance animation
			}
		}
	};
	self.updateRickDance = function (popupGraphic) {
		var pg = popupGraphic; // shorthand for readability
		pg.danceTimer += 1000 / 60 * gameSpeedMultiplier; // Increment timer in ms
		var TILT_DURATION = 300 / gameSpeedMultiplier; // Duration of one tilt/flip segment
		var FLIP_POINT_IN_CYCLE = 2; // At which phase to trigger a flip
		if (pg.danceTimer >= TILT_DURATION) {
			pg.danceTimer = 0;
			pg.dancePhase = (pg.dancePhase + 1) % 4; // Cycle through 4 phases
			if (pg.dancePhase === 0) {
				// Tilt Left
				pg.rotation = -0.15; // Slight tilt in radians
			} else if (pg.dancePhase === 1) {
				// Tilt Right
				pg.rotation = 0.15;
			} else if (pg.dancePhase === 2) {
				// Center rotation
				pg.rotation = pg.originalRotation;
				// Flip horizontally on this phase
				pg.scale.x = -pg.originalScaleX;
			} else if (pg.dancePhase === 3) {
				// Center rotation and flip back
				pg.rotation = pg.originalRotation;
				pg.scale.x = pg.originalScaleX;
			}
		}
	};
	self.findTargetAndFire = function () {
		var buildSpot = self.parent;
		if (!buildSpot || !buildSpot.parent) {
			return;
		}
		// Get tower position in game space
		var towerGraphicGlobalCenter = self.graphic.toGlobal({
			x: 0,
			y: 0
		});
		var towerPosInGameSpace = game.toLocal(towerGraphicGlobalCenter);
		// Find target
		var closestEnemy = null;
		var minDistanceSq = self.range * self.range;
		for (var i = 0; i < enemies.length; i++) {
			var enemy = enemies[i];
			if (!enemy || !enemy.parent) {
				continue;
			}
			var dx = enemy.x - towerPosInGameSpace.x;
			var dy = enemy.y - towerPosInGameSpace.y;
			var distanceSq = dx * dx + dy * dy;
			if (distanceSq < minDistanceSq) {
				minDistanceSq = distanceSq;
				closestEnemy = enemy;
			}
		}
		if (closestEnemy) {
			var targetX = closestEnemy.x;
			var targetY = closestEnemy.y;
			// Create Rick Astley projectile
			var rick = new RickAstleyProjectile(towerPosInGameSpace.x, towerPosInGameSpace.y, targetX, targetY, self);
			self.activeProjectiles.push(rick);
			game.addChild(rick);
			// Start cooldown
			self.currentCooldown = self.cooldown;
		}
	};
	self.activateEffectAtLocation = function (effectX, effectY) {
		// Spawn Rick Astley Popup (Stationary at target)
		var popup = game.attachAsset(self.popupAsset, {
			anchorX: 0.5,
			anchorY: 0.5,
			x: effectX,
			y: effectY
		});
		// Add dance properties to the popup
		popup.isDancing = false;
		popup.dancePhase = 0; // For cycling through dance moves
		popup.danceTimer = 0; // Timer for current dance move
		popup.originalScaleX = popup.scale.x; // Store original scale.x (usually 1)
		popup.originalRotation = popup.rotation; // Store original rotation (usually 0)
		// Add to active popups list
		self.activePopups.push(popup);
		// Fade in/out animation
		popup.alpha = 0;
		tween(popup,
		// target
		{
			alpha: 1.0
		},
		// props
		{
			// options for fade-in
			duration: 250 / gameSpeedMultiplier,
			easing: tween.quadOut,
			onFinish: function onFinish() {
				// After fade-in completes
				// Start dancing once fade-in is complete
				popup.isDancing = true;
				LK.setTimeout(function () {
					// Hold duration
					if (popup && popup.parent) {
						// Stop dancing before fade-out
						popup.isDancing = false;
						// Reset appearance
						popup.rotation = popup.originalRotation;
						popup.scale.x = popup.originalScaleX;
						tween(popup,
						// target for fade-out
						{
							alpha: 0
						},
						// props
						{
							// options for fade-out
							duration: 250 / gameSpeedMultiplier,
							easing: tween.quadIn,
							onFinish: function onFinish() {
								if (popup.parent) {
									// Remove from active popups list
									var index = self.activePopups.indexOf(popup);
									if (index !== -1) {
										self.activePopups.splice(index, 1);
									}
									popup.destroy();
								}
							}
						});
					}
				}, (self.popupDuration - 500) / gameSpeedMultiplier); // Time to hold at full alpha
			}
		});
		// Play Sound
		var soundToPlay = self.soundEffects[Math.floor(Math.random() * self.soundEffects.length)];
		LK.getSound(soundToPlay).play();
		// Find and Stun/Damage Enemies in Effect Radius
		var enemiesAffectedThisTrigger = [];
		for (var i = 0; i < enemies.length; i++) {
			var enemy = enemies[i];
			if (!enemy || !enemy.parent) {
				continue;
			}
			var dx = enemy.x - effectX;
			var dy = enemy.y - effectY;
			var distance = Math.sqrt(dx * dx + dy * dy);
			if (distance < self.effectRadius) {
				if (!enemy.isStunned) {
					enemy.originalSpeed = enemy.speed;
					enemy.speed = 0;
					enemy.isStunned = true;
					enemy.isStunnedByRickroll = self; // So this tower can unstun
					enemy.graphic.tint = 0xFFD700; // Gold tint
					enemiesAffectedThisTrigger.push(enemy);
					// Start DOT on this enemy
					self.startDotOnEnemy(enemy);
				}
			}
		}
		// Unstun Timer
		LK.setTimeout(function () {
			for (var i = 0; i < enemiesAffectedThisTrigger.length; i++) {
				var affectedEnemy = enemiesAffectedThisTrigger[i];
				if (affectedEnemy && affectedEnemy.parent && affectedEnemy.isStunnedByRickroll === self) {
					affectedEnemy.isStunned = false;
					affectedEnemy.speed = affectedEnemy.originalSpeed;
					affectedEnemy.isStunnedByRickroll = null;
					affectedEnemy.graphic.tint = 0xFFFFFF;
				}
			}
		}, self.stunDuration / gameSpeedMultiplier);
	};
	self.startDotOnEnemy = function (enemyInstance) {
		var dotTicksRemaining = Math.floor(self.stunDuration / self.dotTickRate);
		function applyTick() {
			if (!enemyInstance || !enemyInstance.parent || enemyInstance.isStunnedByRickroll !== self || dotTicksRemaining <= 0) {
				return;
			}
			enemyInstance.takeDamage(self.damagePerTick);
			dotTicksRemaining--;
			if (dotTicksRemaining > 0) {
				LK.setTimeout(applyTick, self.dotTickRate / gameSpeedMultiplier);
			}
		}
		applyTick(); // Start the first tick
	};
	return self;
});
var SpamEmailUnit = Container.expand(function () {
	var self = Container.call(this);
	self.walkFrames = ['enemySpamEmail', 'enemySpamEmail_walk_1', 'enemySpamEmail_walk_2']; // Animation frames
	self.currentAnimFrame = 0;
	self.animationSpeed = 6;
	self.animationCounter = 0;
	self.graphic = self.attachAsset(self.walkFrames[0], {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.health = 2; // Very low health
	self.speed = 2.5; // Moderately fast
	self.value = 1; // Very low currency reward
	self.isFlying = true; // Mark as flying
	self.update = function () {
		// Check if pathPoints is loaded and valid
		if (!pathPoints || pathPoints.length === 0) {
			return;
		}
		// Flying units go directly to the goal (last point in path)
		var target = pathPoints[pathPoints.length - 1];
		if (!target) {
			self.destroy();
			return;
		}
		var dx = target.x - self.x;
		var dy = target.y - self.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		// Check if reached the goal
		if (distance < self.speed * 1.5) {
			playerLives--;
			livesText.setText("Lives: " + playerLives);
			LK.getSound('enemyReachGoal').play();
			if (playerLives <= 0) {
				// Game over
				if (LK.getScore() > storage.highScore) {
					storage.highScore = LK.getScore();
				}
				LK.showGameOver();
			}
			self.destroy();
			return;
		} else {
			// Move directly towards the goal
			dx = dx / distance * self.speed * gameSpeedMultiplier;
			dy = dy / distance * self.speed * gameSpeedMultiplier;
			self.x += dx;
			self.y += dy;
		}
		// --- Animation Logic ---
		if (self.walkFrames && self.walkFrames.length > 1) {
			// Only animate if there's more than one frame
			self.animationCounter += gameSpeedMultiplier; // Respect game speed
			if (self.animationCounter >= self.animationSpeed) {
				self.animationCounter = 0;
				self.currentAnimFrame = (self.currentAnimFrame + 1) % self.walkFrames.length;
				var newAssetIdToAttach = self.walkFrames[self.currentAnimFrame];
				if (self.graphic && self.graphic.parent) {
					// Preserve local position if self.graphic is a direct child of self
					var currentLocalX = self.graphic.x;
					var currentLocalY = self.graphic.y;
					self.removeChild(self.graphic); // Or self.graphic.destroy(); if that's more appropriate
					self.graphic = self.attachAsset(newAssetIdToAttach, {
						anchorX: 0.5,
						anchorY: 0.5,
						x: currentLocalX,
						// Restore local x
						y: currentLocalY // Restore local y
					});
				} else if (!self.graphic && self.parent) {
					// If graphic was lost but enemy still exists
					self.graphic = self.attachAsset(newAssetIdToAttach, {
						anchorX: 0.5,
						anchorY: 0.5
					});
				}
			}
		}
		// --- End Animation Logic ---
	};
	self.takeDamage = function (amount) {
		self.health -= amount;
		// Flash red when taking damage
		LK.effects.flashObject(self, 0xff0000, 200);
		if (self.health <= 0 && self.parent) {
			// Added check for self.parent before accessing currency
			// Determine number of coins to drop based on enemy value
			var numCoins = Math.ceil(self.value / 5); // 1 coin per 5 value, min 1
			if (numCoins < 1) {
				numCoins = 1;
			}
			// Spawn multiple coins
			for (var i = 0; i < numCoins; i++) {
				var coin = new DogeCoin(self.x, self.y, Math.floor(self.value / numCoins));
				if (game.coinLayer) {
					game.coinLayer.addChild(coin);
				} else {
					coinLayer.addChild(coin);
				}
			}
			// Score still goes up immediately
			LK.setScore(LK.getScore() + self.value);
			scoreText.setText("Score: " + LK.getScore());
			LK.getSound('enemyDeath').play();
			self.destroy();
		}
	};
	return self;
});
// --- Base Tower Functionality (Conceptual - can be mixed into specific towers) ---
// This isn't a formal class, but concepts to apply
// Modify StaplerTower
// --- MODIFY StaplerTower ---
var StaplerTower = Container.expand(function () {
	var self = Container.call(this);
	// --- MODIFIED: No graphic initialization in constructor ---
	self.lastFired = 0;
	// init method removed - functionality moved to constructor and initializeTowerFromData
	self.update = function () {
		self.lastFired += gameSpeedMultiplier;
		if (self.lastFired >= self.fireRate) {
			var closestEnemy = null;
			var minDistanceSq = self.range * self.range;
			var buildSpot = self.parent; // Tower is child of BuildSpot
			if (!buildSpot || !buildSpot.parent) {
				return;
			}
			var levelContainer = buildSpot.parent; // BuildSpot is child of Level
			var towerGraphicGlobalCenter = self.graphic.toGlobal({
				x: 0,
				y: 0
			});
			var towerCenterInGameSpace = game.toLocal(towerGraphicGlobalCenter);
			for (var i = 0; i < enemies.length; i++) {
				var enemy = enemies[i];
				var dx = enemy.x - towerCenterInGameSpace.x;
				var dy = enemy.y - towerCenterInGameSpace.y;
				var distanceSq = dx * dx + dy * dy; // Squared distance check
				if (distanceSq < minDistanceSq) {
					minDistanceSq = distanceSq;
					closestEnemy = enemy;
				}
			}
			if (closestEnemy) {
				self.shoot(closestEnemy);
				self.lastFired = 0;
			}
		}
	};
	self.shoot = function (target) {
		var bullet = new TowerBullet();
		var buildSpot = self.parent;
		if (!buildSpot || !buildSpot.parent) {
			return;
		}
		var levelContainer = buildSpot.parent;
		var towerGraphicGlobalCenter = self.graphic.toGlobal({
			x: 0,
			y: 0
		});
		var bulletSpawnPosInGameSpace = game.toLocal(towerGraphicGlobalCenter);
		bullet.x = bulletSpawnPosInGameSpace.x;
		bullet.y = bulletSpawnPosInGameSpace.y;
		bullet.target = target;
		bullet.damage = self.damage;
		game.addChild(bullet);
		bullets.push(bullet);
		LK.getSound('shoot').play();
	};
	// Initialize tower with level 0 stats and graphics
	initializeTowerFromData(self, 'stapler', 0); // Set initial stats & correct L0 asset
	return self;
});
var ThisIsFinePit = Container.expand(function () {
	var self = Container.call(this);
	// Initialize buffer tower properties
	self.nearbyTowers = [];
	self.currentBuffStacks = 0;
	self.lastSoundPlayed = null; // For managing dynamic audio
	self.soundCooldown = 0; // To prevent voice lines spamming
	// Initialize the tower with level 0 stats and graphics
	initializeTowerFromData(self, 'thisIsFine', 0);
	self.update = function () {
		// A. Count Enemies in Range
		var buildSpot = self.parent;
		if (!buildSpot || !buildSpot.parent) {
			return;
		}
		var pitPosInGameSpace;
		var towerGraphicGlobalCenter = self.graphic.toGlobal({
			x: 0,
			y: 0
		});
		pitPosInGameSpace = game.toLocal(towerGraphicGlobalCenter);
		// Count how many enemies are within range
		var enemyCountInRange = 0;
		for (var i = 0; i < enemies.length; i++) {
			var enemy = enemies[i];
			if (enemy && enemy.parent) {
				var dx = enemy.x - pitPosInGameSpace.x;
				var dy = enemy.y - pitPosInGameSpace.y;
				var distanceSq = dx * dx + dy * dy;
				if (distanceSq < self.range * self.range) {
					enemyCountInRange++;
				}
			}
		}
		// Cap at max buff stacks
		var activeStacks = Math.min(enemyCountInRange, self.maxBuffStacks);
		// B. Clear Previous Buffs & Find Towers to Buff
		if (self.currentBuffStacks > 0) {
			// Revert stats for previously buffed towers
			for (var i = 0; i < self.nearbyTowers.length; i++) {
				var towerInRange = self.nearbyTowers[i];
				if (towerInRange && towerInRange.parent && towerInRange.hasOwnProperty('originalFireRate') && towerInRange.hasOwnProperty('originalDamage')) {
					towerInRange.fireRate = towerInRange.originalFireRate;
					towerInRange.damage = towerInRange.originalDamage;
				}
			}
			// Clear the array of nearby towers
			self.nearbyTowers = [];
		}
		// Find all towers within range
		if (level && level.buildSpots) {
			for (var i = 0; i < level.buildSpots.length; i++) {
				var spot = level.buildSpots[i];
				if (spot.hasTower && spot.tower && spot.tower !== self) {
					// Get tower position in game space
					var towerPos = spot.tower.graphic.toGlobal({
						x: 0,
						y: 0
					});
					var otherTowerPosInGameSpace = game.toLocal(towerPos);
					// Check if tower is in range
					var dx = otherTowerPosInGameSpace.x - pitPosInGameSpace.x;
					var dy = otherTowerPosInGameSpace.y - pitPosInGameSpace.y;
					var distanceSq = dx * dx + dy * dy;
					if (distanceSq < self.range * self.range) {
						self.nearbyTowers.push(spot.tower);
					}
				}
			}
		}
		// C. Apply New Buffs
		self.currentBuffStacks = activeStacks;
		if (activeStacks > 0) {
			// Calculate buff multipliers
			var speedMultiplier = 1.0 - self.attackSpeedBuffPerStack * activeStacks;
			var damageMultiplier = 1.0 + self.damageBuffPerStack * activeStacks;
			// Apply buffs to nearby towers
			for (var i = 0; i < self.nearbyTowers.length; i++) {
				var towerInRange = self.nearbyTowers[i];
				// Store original values if not already stored
				if (!towerInRange.hasOwnProperty('originalFireRate')) {
					towerInRange.originalFireRate = towerInRange.fireRate;
				}
				if (!towerInRange.hasOwnProperty('originalDamage')) {
					towerInRange.originalDamage = towerInRange.damage;
				}
				// Apply buffs
				towerInRange.fireRate = Math.max(5, Math.floor(towerInRange.originalFireRate * speedMultiplier));
				towerInRange.damage = towerInRange.originalDamage * damageMultiplier;
			}
		}
		// D. Dynamic Audio Logic
		if (self.soundCooldown > 0) {
			self.soundCooldown -= gameSpeedMultiplier;
		}
		if (activeStacks === 0 && self.lastSoundPlayed !== 'gentle') {
			// Stop other fire sounds if playing
			// Play sfxThisIsFineFireGentle (looping)
			self.lastSoundPlayed = 'gentle';
		} else if (activeStacks > 0 && activeStacks <= 2 && self.lastSoundPlayed !== 'medium') {
			// Stop other fire sounds
			// Play sfxThisIsFineFireMedium (looping)
			self.lastSoundPlayed = 'medium';
			if (self.soundCooldown <= 0) {
				// Play sfxThisIsFineVoice1
				self.soundCooldown = 300; // 5s
			}
		} else if (activeStacks > 2 && self.lastSoundPlayed !== 'roar') {
			// Stop other fire sounds
			// Play sfxThisIsFineFireRoar (looping)
			self.lastSoundPlayed = 'roar';
			if (self.soundCooldown <= 0) {
				// Play sfxThisIsFineVoice2
				self.soundCooldown = 300;
			}
		}
	};
	// Override destroy to clean up buffs when tower is destroyed
	var originalDestroy = self.destroy;
	self.destroy = function () {
		// Revert all buffs before destroying
		for (var i = 0; i < self.nearbyTowers.length; i++) {
			var towerInRange = self.nearbyTowers[i];
			if (towerInRange && towerInRange.parent && towerInRange.hasOwnProperty('originalFireRate') && towerInRange.hasOwnProperty('originalDamage')) {
				towerInRange.fireRate = towerInRange.originalFireRate;
				towerInRange.damage = towerInRange.originalDamage;
			}
		}
		// Stop any looping fire sounds
		// Call original destroy
		if (originalDestroy) {
			originalDestroy.call(self);
		} else if (self.parent) {
			self.parent.removeChild(self);
		}
	};
	return self;
});
// TowerBullet class remains the same
var TowerBullet = Container.expand(function () {
	var self = Container.call(this);
	var graphic = self.attachAsset('bullet', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.speed = 10;
	self.damage = 1;
	self.target = null;
	self.update = function () {
		// Check if target exists and is still in the game
		if (!self.target || !self.target.parent) {
			self.destroy();
			return;
		}
		var dx = self.target.x - self.x;
		var dy = self.target.y - self.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		// Use speed as collision threshold
		if (distance < self.speed) {
			self.target.takeDamage(self.damage);
			self.destroy();
			return;
		}
		// Normalize and multiply by speed
		dx = dx / distance * self.speed * gameSpeedMultiplier;
		dy = dy / distance * self.speed * gameSpeedMultiplier;
		self.x += dx;
		self.y += dy;
	};
	return self;
});

/**** 
* Initialize Game
****/ 
var game = new LK.Game({
	backgroundColor: 0x558855 // Darker green background
});

/**** 
* Game Code
****/ 
// (Optional) Sounds
// (Optional) Effect for "restructuring"
// New Tower - Restructuring Specialist
// Add upgrade method to both tower types via initializeTowerFromData
// --- Base Tower Functionality (Conceptual - can be mixed into specific towers) ---
// var towerCenterInGameSpace = game.toLocal(towerGraphicGlobalCenter);
function createRangeIndicator(centerX, centerY, radius, parentContainer) {
	return new RangeIndicator(centerX, centerY, radius, parentContainer);
}
function addUpgradeToTower(towerInstance) {
	towerInstance.upgrade = function () {
		// Check if next level exists
		if (!this.towerType || !TOWER_DATA[this.towerType]) {
			return false;
		}
		var nextLevel = this.currentLevel + 1;
		var towerTypeData = TOWER_DATA[this.towerType];
		// Check if next level data exists
		if (!towerTypeData.levels[nextLevel]) {
			spawnFloatingText("MAX LEVEL!", this.parent.x, this.parent.y - 50, {
				fill: 0xFFD700
			});
			return false;
		}
		// Get upgrade cost
		var upgradeCost = towerTypeData.levels[nextLevel].cost;
		// Check if player can afford upgrade
		if (currency < upgradeCost) {
			spawnFloatingText("Need more $!", this.parent.x, this.parent.y - 50, {
				fill: 0xFF0000
			});
			return false;
		}
		// Pay for upgrade
		currency -= upgradeCost;
		currencyText.setText("$: " + currency);
		// Apply upgrade
		initializeTowerFromData(this, this.towerType, nextLevel);
		// Play upgrade sound
		LK.getSound('uiSelectTower').play();
		// Show upgrade message
		spawnFloatingText("UPGRADED!", this.parent.x, this.parent.y - 50, {
			fill: 0x00FF00
		});
		// Hide upgrade menu
		if (this.parent && typeof this.parent.hideUpgradeMenu === 'function') {
			this.parent.hideUpgradeMenu();
		}
		return true;
	};
}
// Specific build sounds for each tower type if desired
// --- New Sound Effects ---
// Bureaucracy Blocker
// Even more so
// Slightly bigger/cooler
// Stapler
// --- Tower Level Assets (Placeholders) ---
// You'll also need actual tower icons for the buttons eventually
// For + symbols
// --- UI Assets for Popup ---
// Added sound for auto-attack
// Game constants
// <-- NEW Green Target Marker
// --- NEW ASSETS ---
// Placeholder path
// Placeholder path
// Sound for bureaucracy blocker or paperwork
// Sound for red tape worm
// --- TOWER DEFINITIONS ---
// Tower data is defined below
// Function to initialize or upgrade tower with data from TOWER_DATA
function initializeTowerFromData(towerInstance, towerTypeKey, levelIndex) {
	if (!towerInstance || !TOWER_DATA[towerTypeKey] || !TOWER_DATA[towerTypeKey].levels || !TOWER_DATA[towerTypeKey].levels[levelIndex]) {
		console.error("Invalid tower, type, or level data for initialization");
		return;
	}
	var levelData = TOWER_DATA[towerTypeKey].levels[levelIndex];
	// Store tower type and level
	towerInstance.towerType = towerTypeKey;
	towerInstance.currentLevel = levelIndex;
	// Assign all properties from levelData to the tower
	for (var key in levelData) {
		if (key !== 'asset' && key !== 'cost' && key !== 'description') {
			towerInstance[key] = levelData[key];
		}
	}
	// Graphic handling:
	if (towerInstance.graphic && towerInstance.graphic.parent) {
		// If graphic exists and is attached, update it
		towerInstance.graphic.parent.removeChild(towerInstance.graphic);
		towerInstance.graphic = towerInstance.attachAsset(levelData.asset, {
			anchorX: 0.5,
			anchorY: 0.5
		});
	} else {
		// If graphic doesn't exist or is detached, create a new one
		if (towerInstance.graphic) {
			towerInstance.graphic.destroy(); // Clean up old if it existed but was detached
		}
		towerInstance.graphic = towerInstance.attachAsset(levelData.asset, {
			anchorX: 0.5,
			anchorY: 0.5
		});
	}
	// Tower-specific re-initialization logic
	if (towerTypeKey === 'stapler' && towerInstance.hasOwnProperty('lastFired')) {
		towerInstance.lastFired = 0; // Reset fire cooldown on init/upgrade
	}
	if (towerTypeKey === 'blocker' && typeof towerInstance.clearAllSlows === 'function') {
		towerInstance.clearAllSlows(); // Ensure slows are reset based on new stats
	}
	// Add upgrade method if not already present
	if (!towerInstance.upgrade) {
		addUpgradeToTower(towerInstance);
	}
}
// --- GLOBAL DEFINITION FOR ICON OFFSETS ---
// buildSpot graphic width is 150, icon width is ~80-100. Adjust offsets as needed.
var ICON_SELECT_OFFSETS = [{
	x: -170,
	y: -110,
	towerKey: 'stapler'
}, {
	x: 0,
	y: -200,
	towerKey: 'blocker'
}, {
	x: 170,
	y: -110,
	towerKey: 'laserCat'
}, {
	x: -170,
	y: 110,
	towerKey: 'rickroller'
}, {
	x: 0,
	y: 200,
	towerKey: 'thisIsFine'
}, {
	x: 170,
	y: 110,
	towerKey: 'restruct'
}];
var TOWER_DATA = {
	'stapler': {
		name: 'Stapler Turret',
		iconAsset: 'towerStaplerLvl1',
		// Use Lvl1 icon for selection button initially
		buildSfx: 'buildStapler',
		levels: [{
			asset: 'towerStaplerLvl1',
			cost: 50,
			damage: 1,
			range: 400,
			fireRate: 60,
			description: "Basic Stapler"
		}, {
			asset: 'towerStaplerLvl2',
			cost: 150,
			damage: 3,
			range: 420,
			fireRate: 55,
			description: "Improved Firepower"
		}, {
			asset: 'towerStaplerLvl3',
			cost: 300,
			damage: 4,
			range: 450,
			fireRate: 50,
			description: "Max Staples!"
		}]
	},
	'blocker': {
		name: 'Bureaucracy Blocker',
		iconAsset: 'towerBlockerLvl1',
		buildSfx: 'buildBlocker',
		levels: [{
			asset: 'towerBlockerLvl1',
			cost: 75,
			slowFactor: 0.5,
			range: 320,
			description: "Slows nearby red tape."
		}, {
			asset: 'towerBlockerLvl2',
			cost: 300,
			slowFactor: 0.4,
			range: 350,
			description: "Wider, stronger slow."
		},
		// 0.4 means 60% speed reduction
		{
			asset: 'towerBlockerLvl3',
			cost: 600,
			slowFactor: 0.3,
			range: 400,
			description: "Bureaucratic Gridlock!"
		}]
	},
	'laserCat': {
		name: 'Laser Cat Perch',
		iconAsset: 'towerLaserCatLvl1',
		buildSfx: 'buildLaserCat',
		levels: [{
			// Level 1
			asset: 'towerLaserCatLvl1',
			cost: 150,
			range: 500,
			initialBeamDamage: 1,
			// Damage when beam first hits
			dotDamagePerSecond: 1,
			// Base DOT
			dotRampUpFactor: 1.2,
			// Multiplier for DOT each second it stays on same target (e.g., 2, then 2*1.2, then 2*1.2*1.2)
			maxBeamDuration: 3000,
			// Milliseconds (3 seconds) beam can stay on one target
			cooldownBetweenBeams: 4000,
			// Milliseconds (4 seconds) after a beam finishes
			numberOfBeams: 1,
			// Targets 1 enemy
			description: "Pew pew! Precision feline firepower. Damage ramps up."
		}, {
			// Level 2
			asset: 'towerLaserCatLvl1',
			// Placeholder - use 'towerLaserCatLvl2' when ready
			cost: 600,
			range: 550,
			initialBeamDamage: 5,
			dotDamagePerSecond: 2,
			dotRampUpFactor: 1.25,
			maxBeamDuration: 3500,
			cooldownBetweenBeams: 3500,
			numberOfBeams: 2,
			// Targets 2 enemies
			description: "Dual-core processing! More lasers, more ouch."
		}, {
			// Level 3
			asset: 'towerLaserCatLvl1',
			// Placeholder - use 'towerLaserCatLvl3' when ready
			cost: 1200,
			range: 600,
			initialBeamDamage: 10,
			dotDamagePerSecond: 5,
			dotRampUpFactor: 1.3,
			maxBeamDuration: 4000,
			cooldownBetweenBeams: 3000,
			numberOfBeams: 3,
			// Targets 3 enemies
			description: "Maximum laser focus! It's a light show of doom."
		}]
	},
	'rickroller': {
		name: 'Rickroller Trap',
		iconAsset: 'towerRickrollerLvl1',
		buildSfx: 'sfxRickrollerPlace',
		// Changed to match your SFX list
		levels: [{
			asset: 'towerRickrollerLvl1',
			cost: 175,
			damagePerTick: 1,
			dotTickRate: 500,
			// Milliseconds
			effectRadius: 200,
			// Radius of stun/damage from impact
			stunDuration: 2000,
			// Milliseconds
			popupDuration: 3000,
			// Milliseconds
			popupAsset: 'rickAstleyPopup',
			soundEffects: ['sfxRickrollTrigger1', 'sfxRickrollTrigger2', 'sfxRickrollTrigger3'],
			// Array of sound variants
			cooldown: 10000,
			// Milliseconds from when the tower fires
			range: 400,
			// Range of the TOWER to decide where to shoot the trap
			projectileSpeed: 7,
			// Speed of flying Rick Astley projectile
			description: "Never gonna let them pass! Stuns and confuses."
		}]
	},
	'thisIsFine': {
		name: "'This Is Fine' Fire Pit",
		iconAsset: 'towerThisIsFineLvl1',
		buildSfx: 'buildThisIsFine',
		// Define this sound
		levels: [{
			asset: 'towerThisIsFineLvl1',
			cost: 125,
			range: 650,
			// Aura buff range
			maxBuffStacks: 5,
			// How many nearby enemies contribute to max buff
			attackSpeedBuffPerStack: 0.05,
			// e.g., 5% faster per stack (0.95 multiplier)
			damageBuffPerStack: 0.05,
			// e.g., 5% more damage per stack (1.05 multiplier)
			description: "Everything's fine. Totally fine. Buffs nearby towers."
		}]
	},
	'restruct': {
		name: 'Restructuring Specialist',
		iconAsset: 'towerRestructLvl1',
		buildSfx: 'buildRestruct',
		levels: [{
			asset: 'towerRestructLvl1',
			cost: 500,
			damage: 100,
			instantKillThreshold: 25,
			range: 450,
			chargeUpTime: 360,
			targetPriority: 'strongest',
			effectAsset: 'restructureEffect',
			description: "Optimizing threats... permanently."
		}, {
			asset: 'towerRestructLvl1',
			cost: 1000,
			damage: 150,
			instantKillThreshold: 35,
			range: 600,
			chargeUpTime: 300,
			targetPriority: 'strongest',
			effectAsset: 'restructureEffect',
			description: "Synergistic realignment for enhanced efficiency."
		}, {
			asset: 'towerRestructLvl1',
			cost: 2000,
			damage: 200,
			instantKillThreshold: 50,
			range: 700,
			chargeUpTime: 250,
			targetPriority: 'strongest',
			effectAsset: 'restructureEffect',
			goldenParachuteDamage: 25,
			goldenParachuteRadius: 100,
			description: "Downsizing comes with... severance packages."
		}]
	}
	// Add more tower types here later
};
var gameSpeedMultiplier = 1.0; // Default game speed
var TOWER_COST = 50;
var WAVE_DELAY = 300; // frames between waves
var MAX_WAVES = 10;
// Access screen dimensions directly from LK
var SCREEN_HEIGHT = 2732; // Standard iPad Pro height (portrait mode)
var SCREEN_WIDTH = 2048; // Standard iPad Pro width (portrait mode)
var PAN_THRESHOLD = SCREEN_HEIGHT * 0.25; // Start panning when Doge is in top/bottom 25% /**** NEW ****/
var MAP_WIDTH = 3000; // Example: roughly double current screen width
var MAP_HEIGHT = 4500; // Let's increase this too if we're expanding
// Game variables
var coinLayer;
var enemyLayer;
var currency = 100;
var playerLives = 5;
var currentWave = 0;
var waveTimer = 0;
var isWaveActive = false;
var enemies = [];
var bullets = [];
var pathPoints = [];
var currentActiveBuildSpot = null;
var level;
var doge;
var goal;
// --- HELPER FUNCTION FOR FLOATING TEXT ---
function isChildOf(possibleParent, target) {
	if (!target || !target.parent) {
		return false;
	}
	if (target.parent === possibleParent) {
		return true;
	}
	return isChildOf(possibleParent, target.parent);
}
// Function to update the visual state of speed buttons
function updateSpeedButtonVisuals() {
	if (game.normalSpeedButton && game.fastSpeedButton) {
		if (gameSpeedMultiplier === 1.0) {
			game.normalSpeedButton.setText("Regular Work Day", {
				fill: 0xFFFFFF // Active
			});
			game.fastSpeedButton.setText("Crunch Time!", {
				fill: 0xDDDDDD // Inactive
			});
		} else {
			game.normalSpeedButton.setText("Regular Work Day", {
				fill: 0xDDDDDD // Inactive
			});
			game.fastSpeedButton.setText("Crunch Time!", {
				fill: 0xFFD700 // Gold/active
			});
		}
	}
}
function spawnFloatingText(text, x, y, options) {
	var defaultOptions = {
		size: 30,
		fill: 0xFFFFFF,
		// White text
		stroke: 0x000000,
		strokeThickness: 2,
		duration: 60,
		// frames (1 second at 60fps)
		velocityY: -1.5,
		// Pixels per frame upwards
		alphaFadeSpeed: 0.015
	};
	var settings = Object.assign({}, defaultOptions, options); // Merge user options
	var floatingText = new Text2(text, {
		size: settings.size,
		fill: settings.fill,
		stroke: settings.stroke,
		strokeThickness: settings.strokeThickness,
		anchorX: 0.5,
		// Center the text
		anchorY: 0.5
	});
	floatingText.x = x;
	floatingText.y = y;
	floatingText.alpha = 1.0;
	game.addChild(floatingText); // Add to main game container to scroll with world
	var framesLived = 0;
	floatingText.update = function () {
		floatingText.y += settings.velocityY * gameSpeedMultiplier;
		floatingText.alpha -= settings.alphaFadeSpeed * gameSpeedMultiplier;
		framesLived += gameSpeedMultiplier;
		if (framesLived >= settings.duration || floatingText.alpha <= 0) {
			floatingText.destroy();
		}
	};
	// Add this to a list of updatable text objects if your engine doesn't auto-update children with .update
	// For LK Engine, if it's a child of `game` and has an `update` method, it should be called.
	// If not, you'll need a global array like `activeFloatingTexts` and iterate it in `game.update`.
	// Let's assume LK.Game handles child updates for now.
}
var scoreText = new Text2("Score: 0", {
	size: 50,
	fill: 0xFFFFFF
}); // White text
scoreText.anchor.set(0.5, 0);
LK.gui.top.addChild(scoreText);
var waveText = new Text2("Wave: 0/" + MAX_WAVES, {
	size: 50,
	fill: 0xFFFFFF
});
waveText.anchor.set(1, 0); // Anchor top-right
waveText.x = -100; // Position from right edge
LK.gui.topRight.addChild(waveText);
var currencyText = new Text2("$: " + currency, {
	size: 50,
	fill: 0xFFFFFF
});
currencyText.anchor.set(0.5, 0);
currencyText.y = 60;
LK.gui.top.addChild(currencyText);
var livesText = new Text2("Lives: " + playerLives, {
	size: 50,
	fill: 0xFFFFFF
});
livesText.anchor.set(1, 0); // Anchor top-right
livesText.x = -100;
livesText.y = 60;
LK.gui.topRight.addChild(livesText);
// Removed old info text, replaced by Bark button
// var infoText = new Text2(...)
// Bark Button /**** NEW ****/
var barkButton = new Text2("BARK!", {
	size: 100,
	fill: 0xffcc00,
	// Doge color
	stroke: 0x000000,
	strokeThickness: 4
});
barkButton.anchor.set(0.5, 1); // Anchor bottom-center
barkButton.y = -50; // Position from bottom edge
barkButton.interactive = true; // Make it clickable
barkButton.down = function () {
	if (doge) {
		var success = doge.manualBark();
		if (success) {
			// Optional: visual feedback on button press
			barkButton.scale.set(1.1);
			LK.setTimeout(function () {
				barkButton.scale.set(1.0);
			}, 100);
		}
	}
};
LK.gui.bottom.addChild(barkButton);
// Initialize game level and path
function initializeGame() {
	game.y = 0;
	game.scale.set(1); // Reset position and scale
	coinLayer = new Container();
	game.addChild(coinLayer); // coinLayer will be drawn ON TOP of 'level'
	enemyLayer = new Container();
	game.addChild(enemyLayer); // enemyLayer will be drawn ON TOP of 'coinLayer'
	level = new GameLevel();
	game.addChild(level);
	// Create a layer for coins to be placed behind enemies but in front of path
	var coinLayer = new Container();
	game.addChild(coinLayer);
	game.coinLayer = coinLayer; // Store reference for easy access
	// Path Points (Adjust Y values for map height)
	pathPoints = [{
		x: MAP_WIDTH * 0.2,
		y: MAP_HEIGHT * 0.05
	}, {
		x: MAP_WIDTH * 0.2,
		y: MAP_HEIGHT * 0.2
	}, {
		x: MAP_WIDTH * 0.5,
		y: MAP_HEIGHT * 0.2
	}, {
		x: MAP_WIDTH * 0.5,
		y: MAP_HEIGHT * 0.35
	}, {
		x: MAP_WIDTH * 0.7,
		y: MAP_HEIGHT * 0.35
	}, {
		x: MAP_WIDTH * 0.7,
		y: MAP_HEIGHT * 0.5
	}, {
		x: MAP_WIDTH * 0.4,
		y: MAP_HEIGHT * 0.5
	}, {
		x: MAP_WIDTH * 0.3,
		y: MAP_HEIGHT * 0.55
	}, {
		x: MAP_WIDTH * 0.3,
		y: MAP_HEIGHT * 0.7
	}, {
		x: MAP_WIDTH * 0.8,
		y: MAP_HEIGHT * 0.7
	}, {
		x: MAP_WIDTH * 0.6,
		y: MAP_HEIGHT * 0.85
	}, {
		x: MAP_WIDTH * 0.85,
		y: MAP_HEIGHT * 0.85
	}, {
		x: MAP_WIDTH * 0.9,
		y: MAP_HEIGHT * 0.9
	}];
	level.createPath(pathPoints);
	// Build Spots (Adjust Y values for map height)
	var buildSpots = [{
		x: MAP_WIDTH * 0.15,
		y: MAP_HEIGHT * 0.15
	}, {
		x: MAP_WIDTH * 0.35,
		y: MAP_HEIGHT * 0.15
	}, {
		x: MAP_WIDTH * 0.22,
		y: MAP_HEIGHT * 0.25
	}, {
		x: MAP_WIDTH * 0.37,
		y: MAP_HEIGHT * 0.25
	}, {
		x: MAP_WIDTH * 0.75,
		y: MAP_HEIGHT * 0.42
	}, {
		x: MAP_WIDTH * 0.6,
		y: MAP_HEIGHT * 0.45
	}, {
		x: MAP_WIDTH * 0.25,
		y: MAP_HEIGHT * 0.625
	}, {
		x: MAP_WIDTH * 0.78,
		y: MAP_HEIGHT * 0.645
	}, {
		x: MAP_WIDTH * 0.55,
		y: MAP_HEIGHT * 0.6
	}, {
		x: MAP_WIDTH * 0.5,
		y: MAP_HEIGHT * 0.78
	}, {
		x: MAP_WIDTH * 0.79,
		y: MAP_HEIGHT * 0.78
	}, {
		x: MAP_WIDTH * 0.65,
		y: MAP_HEIGHT * 0.75
	}, {
		x: MAP_WIDTH * 0.79,
		y: MAP_HEIGHT * 0.91
	}];
	level.createBuildSpots(buildSpots);
	// Goal
	goal = new Goal();
	if (pathPoints.length > 0) {
		goal.x = pathPoints[pathPoints.length - 1].x;
		goal.y = pathPoints[pathPoints.length - 1].y;
		game.addChild(goal);
	}
	// Doge
	doge = new DogeHero();
	doge.x = SCREEN_WIDTH / 2;
	doge.y = SCREEN_HEIGHT / 2;
	doge.targetX = doge.x;
	doge.targetY = doge.y;
	game.addChild(doge);
	// Reset Variables
	currency = 100;
	playerLives = 5;
	currentWave = 0;
	waveTimer = 0;
	isWaveActive = false;
	enemies.forEach(function (e) {
		if (e.parent) {
			e.destroy();
		}
	});
	enemies = [];
	bullets.forEach(function (b) {
		if (b.parent) {
			b.destroy();
		}
	});
	bullets = [];
	// Reset UI
	currencyText.setText("$: " + currency);
	livesText.setText("Lives: " + playerLives);
	waveText.setText("Wave: " + currentWave + "/" + MAX_WAVES);
	scoreText.setText("Score: " + LK.getScore());
	barkButton.setText("BARK!");
	// Create game speed control buttons
	var normalSpeedButton = new Text2("Regular Work Day", {
		size: 60,
		fill: 0xFFFFFF,
		// Active initially
		stroke: 0x000000,
		strokeThickness: 2
	});
	normalSpeedButton.anchor.set(1, 0);
	normalSpeedButton.x = -100;
	normalSpeedButton.y = 200;
	normalSpeedButton.interactive = true;
	normalSpeedButton.down = function () {
		gameSpeedMultiplier = 1.0;
		updateSpeedButtonVisuals();
		LK.getSound('uiSelectTower').play();
	};
	LK.gui.topRight.addChild(normalSpeedButton);
	var fastSpeedButton = new Text2("Crunch Time!", {
		size: 60,
		fill: 0xDDDDDD,
		// Dimmer initially
		stroke: 0x000000,
		strokeThickness: 2
	});
	fastSpeedButton.anchor.set(1, 0);
	fastSpeedButton.x = -100;
	fastSpeedButton.y = 300;
	fastSpeedButton.interactive = true;
	fastSpeedButton.down = function () {
		gameSpeedMultiplier = 2.0;
		updateSpeedButtonVisuals();
		LK.getSound('uiSelectTower').play();
	};
	LK.gui.topRight.addChild(fastSpeedButton);
	// Store buttons as global variables for accessing elsewhere
	game.normalSpeedButton = normalSpeedButton;
	game.fastSpeedButton = fastSpeedButton;
	// Initialize button visuals
	updateSpeedButtonVisuals();
	LK.playMusic('bgmusic');
}
currentActiveBuildSpot = null;
function spawnWave() {
	currentWave++;
	waveText.setText("Wave: " + currentWave + "/" + MAX_WAVES);
	var baseEnemyCountPerWave = 5 + currentWave * 2;
	var enemiesToSpawnThisWave = [];
	// --- Define enemy composition for this wave ---
	if (currentWave <= 2) {
		// Waves 1-2: Paper & Interns
		for (var i = 0; i < baseEnemyCountPerWave; i++) {
			if (Math.random() < 0.6) {
				enemiesToSpawnThisWave.push(Enemy);
			} else {
				enemiesToSpawnThisWave.push(InternOnCoffeeRun);
			}
		}
	} else if (currentWave >= 3 && currentWave <= 9) {
		// Waves 3-9: Paper, Interns, Spam Emails
		var actualCountForThisWave = baseEnemyCountPerWave;
		for (var i = 0; i < actualCountForThisWave; i++) {
			var r = Math.random();
			if (r < 0.4) {
				enemiesToSpawnThisWave.push(Enemy);
			} else if (r < 0.7) {
				enemiesToSpawnThisWave.push(InternOnCoffeeRun);
			} else {
				enemiesToSpawnThisWave.push(SpamEmailUnit);
			}
		}
	} else if (currentWave === 10) {
		// Wave 10: Mix + 3 Auditors
		enemiesToSpawnThisWave.push(AuditorBot);
		enemiesToSpawnThisWave.push(AuditorBot);
		enemiesToSpawnThisWave.push(AuditorBot);
		var remainingCount = baseEnemyCountPerWave - 3;
		if (remainingCount < 0) {
			remainingCount = 0;
		}
		for (var i = 0; i < remainingCount; i++) {
			var r = Math.random();
			if (r < 0.3) {
				enemiesToSpawnThisWave.push(Enemy);
			} else if (r < 0.6) {
				enemiesToSpawnThisWave.push(InternOnCoffeeRun);
			} else {
				enemiesToSpawnThisWave.push(SpamEmailUnit);
			}
		}
		// Shuffle the array so auditors don't always come first/last
		enemiesToSpawnThisWave.sort(function () {
			return Math.random() - 0.5;
		});
	} else {
		// Fallback for waves > 10 (or unhandled cases)
		for (var i = 0; i < baseEnemyCountPerWave; i++) {
			enemiesToSpawnThisWave.push(Enemy); // Default to Paper
		}
	}
	var spawnInterval = 60;
	var spawnIndex = 0;
	function spawnIndividualEnemy() {
		if (spawnIndex >= enemiesToSpawnThisWave.length || !pathPoints || pathPoints.length === 0) {
			isWaveActive = true;
			return;
		}
		var enemyTypeToSpawn = enemiesToSpawnThisWave[spawnIndex];
		var enemy = new enemyTypeToSpawn();
		enemy.x = pathPoints[0].x;
		enemy.y = pathPoints[0].y;
		// Apply wave-based health scaling if you re-add it:
		// enemy.health += Math.floor(currentWave * 0.5); 
		enemyLayer.addChild(enemy);
		enemies.push(enemy);
		spawnIndex++;
		if (spawnIndex < enemiesToSpawnThisWave.length) {
			LK.setTimeout(spawnIndividualEnemy, spawnInterval * 16.67 / gameSpeedMultiplier);
		} else {
			isWaveActive = true;
		}
	}
	isWaveActive = false;
	if (enemiesToSpawnThisWave.length > 0) {
		spawnIndividualEnemy();
	} else {
		isWaveActive = true; // No enemies defined for this wave
	}
}
function checkWaveComplete() {
	if (isWaveActive && enemies.length === 0) {
		// Double check if we really spawned everything for the wave before proceeding
		// This basic check assumes spawning finishes before all enemies are killed
		isWaveActive = false;
		waveTimer = 0; // Reset timer for next wave delay
		if (currentWave >= MAX_WAVES) {
			// Player wins
			if (LK.getScore() > storage.highScore) {
				storage.highScore = LK.getScore();
			}
			LK.showYouWin();
		}
	}
}
// Event Handlers /**** MODIFIED ****/
// --- NEW APPROACH game.down ---
game.down = function (x, y, obj) {
	var worldX = x;
	var worldY = y;
	// --- 1. Active UI Interaction (Menus, Dialogs) ---
	// Check Build Selection Icons
	if (currentActiveBuildSpot && currentActiveBuildSpot.areIconsVisible && currentActiveBuildSpot.selectionIconContainer) {
		var icons = currentActiveBuildSpot.selectionIconContainer.children;
		for (var i = 0; i < icons.length; i++) {
			// Check if the click was directly on an icon OR an interactive child of an icon
			if ((obj === icons[i] || isChildOf(icons[i], obj)) && obj.interactive) {
				// The icon's own .down() handler will be called by the engine.
				return; // CRITICAL: Stop further processing in game.down
			}
		}
	}
	// Check Tower Action Icons (Upgrade/Sell)
	if (currentActiveBuildSpot && currentActiveBuildSpot.areActionIconsVisible && currentActiveBuildSpot.actionIconContainer) {
		// Assuming areActionIconsVisible flag
		var actionIcons = currentActiveBuildSpot.actionIconContainer.children;
		for (var i = 0; i < actionIcons.length; i++) {
			// Check if the click was directly on an action icon OR an interactive child of an action icon
			if ((obj === actionIcons[i] || isChildOf(actionIcons[i], obj)) && obj.interactive) {
				// The action icon's own .down() handler will be called by the engine.
				return; // CRITICAL: Stop further processing in game.down
			}
		}
	}
	// Placeholder for Sell Confirmation Dialog interaction
	// (Assuming sellConfirmDialog is a global or accessible variable when visible)
	// if (typeof sellConfirmDialog !== 'undefined' && sellConfirmDialog && sellConfirmDialog.parent && sellConfirmDialog.visible) {
	//     // Check if the click was on any interactive part of the sell confirmation dialog
	//     if (obj === sellConfirmDialog.yesButton || obj === sellConfirmDialog.noButton || (isChildOf(sellConfirmDialog, obj) && obj.interactive) ) {
	//         // The button's .down() handler will be called by the engine.
	//         return; // CRITICAL
	//     }
	// }
	// --- 2. Click on Doge (for dragging) ---
	if (doge && obj === doge.graphic) {
		dragDoge = true;
		doge.setTarget(doge.x, doge.y); // Stop current auto-movement
		return; // CRITICAL
	}
	// --- 3. Click on a BuildSpot graphic itself (to toggle its menu) ---
	if (level && level.buildSpots) {
		for (var i = 0; i < level.buildSpots.length; i++) {
			var spot = level.buildSpots[i];
			// Check if the click was directly on the BuildSpot's graphic
			// OR on an interactive child nested within that graphic (if spot.graphic could be a container)
			if (obj === spot.graphic || isChildOf(spot.graphic, obj) && obj.interactive) {
				// The BuildSpot's own .down() handler (spot.down()) should be triggered by the engine
				// to manage its menu visibility.
				return; // CRITICAL
			}
		}
	}
	// --- 4. Close an Open Menu if "Empty Space" was clicked ---
	// This section runs if the click was NOT on an interactive UI icon/button (checked in step 1),
	// NOT on Doge (checked in step 2), and NOT on a BuildSpot graphic itself (checked in step 3).
	// Therefore, if a menu is open, this click is on "empty space" relative to that menu's purpose.
	if (currentActiveBuildSpot) {
		// A general spot has a menu open
		var clickedOnAnotherSpotToOpenItsMenu = false; // Flag to prevent closing if the "empty space" click was actually on another buildspot
		if (level && level.buildSpots) {
			for (var k = 0; k < level.buildSpots.length; k++) {
				if (level.buildSpots[k] !== currentActiveBuildSpot && (obj === level.buildSpots[k].graphic || isChildOf(level.buildSpots[k].graphic, obj) && obj.interactive)) {
					clickedOnAnotherSpotToOpenItsMenu = true;
					break;
				}
			}
		}
		if (!clickedOnAnotherSpotToOpenItsMenu) {
			// Only close if not trying to open another spot's menu
			if (currentActiveBuildSpot.areIconsVisible) {
				// Build selection menu is open
				currentActiveBuildSpot.hideSelectionIcons();
				return; // CRITICAL
			}
			if (currentActiveBuildSpot.areActionIconsVisible) {
				// Tower action menu is open
				currentActiveBuildSpot.hideTowerActionIcons();
				return; // CRITICAL
			}
		}
	}
	// Placeholder for closing Sell Confirmation Dialog on "empty space" click
	// if (typeof sellConfirmDialog !== 'undefined' && sellConfirmDialog && sellConfirmDialog.parent && sellConfirmDialog.visible) {
	//      // Check if the click was outside the dialog content before closing
	//      if (!isChildOf(sellConfirmDialog, obj) && obj !== sellConfirmDialog) { // Basic check: not on dialog or its children
	//          sellConfirmDialog.destroy(); // or hide()
	//          return; // CRITICAL
	//      }
	// }
	// --- 5. Fallback: Move Doge ---
	// If we've reached this point, no UI element was specifically interacted with to trigger an action,
	// Doge wasn't clicked for dragging, no BuildSpot was clicked to toggle a menu,
	// and no menu was open to be closed by an empty space click (or the click was on another spot to open its menu).
	// This means the click was on the general walkable area.
	if (doge) {
		dragDoge = false; // Ensure not dragging if we just clicked empty space
		doge.setTarget(worldX, worldY);
	}
};
game.move = function (x, y, obj) {
	// No doge dragging functionality needed
};
game.up = function (x, y, obj) {
	// No doge dragging functionality needed
};
// Only one game.up function is needed
// Main game loop /**** MODIFIED ****/
game.update = function () {
	// --- Wave Management ---
	if (!isWaveActive && currentWave < MAX_WAVES) {
		// Only increment timer if not won yet
		waveTimer += gameSpeedMultiplier;
		if (waveTimer >= WAVE_DELAY) {
			waveTimer = 0; // Reset timer immediately
			spawnWave();
		}
	}
	// --- Update Bullets --- (Remove destroyed ones)
	for (var i = bullets.length - 1; i >= 0; i--) {
		if (!bullets[i].parent) {
			bullets.splice(i, 1);
		}
	}
	// --- Update Enemies --- (Remove destroyed ones)
	for (var i = enemies.length - 1; i >= 0; i--) {
		if (!enemies[i].parent) {
			enemies.splice(i, 1);
		}
	}
	// --- Update Doge (handles its own cooldowns and attacks) ---
	if (doge && doge.parent) {
		// Check if doge exists
		doge.update(); // Make sure Doge's update runs
	}
	// --- Check Wave Completion ---
	checkWaveComplete();
	// --- Update Bark Button UI --- /**** NEW ****/
	if (doge) {
		// Check if doge exists
		if (doge.currentManualBarkCooldown > 0) {
			var secondsLeft = Math.ceil(doge.currentManualBarkCooldown / 60); // Approx seconds
			barkButton.setText("WAIT (" + secondsLeft + ")");
			barkButton.setText("WAIT (" + secondsLeft + ")", {
				fill: 0x888888
			}); // Grey out text
		} else {
			barkButton.setText("BARK!");
			barkButton.setText("BARK!", {
				fill: 0xffcc00
			}); // Restore color
		}
	}
	// --- Camera Panning Logic ---
	if (doge) {
		var CAM_SMOOTH_FACTOR = 0.1; // Define smoothing factor
		// --- Vertical Panning ---
		var PAN_THRESHOLD_VERTICAL = SCREEN_HEIGHT * 0.25; // Pan when Doge in top/bottom 25%
		var dogeScreenY = doge.y + game.y; // Doge's Y position on the actual screen
		var targetGameY = game.y;
		if (dogeScreenY < PAN_THRESHOLD_VERTICAL) {
			targetGameY = -(doge.y - PAN_THRESHOLD_VERTICAL);
		} else if (dogeScreenY > SCREEN_HEIGHT - PAN_THRESHOLD_VERTICAL) {
			targetGameY = -(doge.y - (SCREEN_HEIGHT - PAN_THRESHOLD_VERTICAL));
		}
		var maxGameY = 0;
		var minGameY = -(MAP_HEIGHT - SCREEN_HEIGHT);
		if (MAP_HEIGHT <= SCREEN_HEIGHT) {
			// Prevent scrolling if map isn't taller
			minGameY = 0;
		}
		targetGameY = Math.max(minGameY, Math.min(maxGameY, targetGameY));
		game.y += (targetGameY - game.y) * CAM_SMOOTH_FACTOR;
		if (Math.abs(game.y - targetGameY) < 1) {
			game.y = targetGameY;
		}
		// --- Horizontal Panning (NEW) ---
		var PAN_THRESHOLD_HORIZONTAL = SCREEN_WIDTH * 0.30; // Pan when Doge in left/right 30%
		var dogeScreenX = doge.x + game.x; // Doge's X position on the actual screen
		var targetGameX = game.x;
		if (dogeScreenX < PAN_THRESHOLD_HORIZONTAL) {
			targetGameX = -(doge.x - PAN_THRESHOLD_HORIZONTAL);
		} else if (dogeScreenX > SCREEN_WIDTH - PAN_THRESHOLD_HORIZONTAL) {
			targetGameX = -(doge.x - (SCREEN_WIDTH - PAN_THRESHOLD_HORIZONTAL));
		}
		var maxGameX = 0;
		var minGameX = -(MAP_WIDTH - SCREEN_WIDTH);
		if (MAP_WIDTH <= SCREEN_WIDTH) {
			// Prevent scrolling if map isn't wider
			minGameX = 0;
		}
		targetGameX = Math.max(minGameX, Math.min(maxGameX, targetGameX));
		game.x += (targetGameX - game.x) * CAM_SMOOTH_FACTOR;
		if (Math.abs(game.x - targetGameX) < 1) {
			game.x = targetGameX;
		}
	}
	// --- End Camera Panning Logic ---
	// --- Dynamically Update Icon Affordability ---
	if (currentActiveBuildSpot && currentActiveBuildSpot.areIconsVisible) {
		currentActiveBuildSpot.updateAffordability();
	}
};
// Initialize the game
LK.setScore(0); // Reset score on start
initializeGame();

===================================================================
--- original.js
+++ change.js
@@ -2746,14 +2746,14 @@
 
 /**** 
 * Game Code
 ****/ 
-// var towerCenterInGameSpace = game.toLocal(towerGraphicGlobalCenter);
-// --- Base Tower Functionality (Conceptual - can be mixed into specific towers) ---
-// Add upgrade method to both tower types via initializeTowerFromData
-// New Tower - Restructuring Specialist
-// (Optional) Effect for "restructuring"
 // (Optional) Sounds
+// (Optional) Effect for "restructuring"
+// New Tower - Restructuring Specialist
+// Add upgrade method to both tower types via initializeTowerFromData
+// --- Base Tower Functionality (Conceptual - can be mixed into specific towers) ---
+// var towerCenterInGameSpace = game.toLocal(towerGraphicGlobalCenter);
 function createRangeIndicator(centerX, centerY, radius, parentContainer) {
 	return new RangeIndicator(centerX, centerY, radius, parentContainer);
 }
 function addUpgradeToTower(towerInstance) {
@@ -3302,10 +3302,10 @@
 	}, {
 		x: MAP_WIDTH * 0.22,
 		y: MAP_HEIGHT * 0.25
 	}, {
-		x: MAP_WIDTH * 0.45,
-		y: MAP_HEIGHT * 0.42
+		x: MAP_WIDTH * 0.37,
+		y: MAP_HEIGHT * 0.25
 	}, {
 		x: MAP_WIDTH * 0.75,
 		y: MAP_HEIGHT * 0.42
 	}, {
@@ -3448,9 +3448,11 @@
 		enemiesToSpawnThisWave.push(AuditorBot);
 		enemiesToSpawnThisWave.push(AuditorBot);
 		enemiesToSpawnThisWave.push(AuditorBot);
 		var remainingCount = baseEnemyCountPerWave - 3;
-		if (remainingCount < 0) remainingCount = 0;
+		if (remainingCount < 0) {
+			remainingCount = 0;
+		}
 		for (var i = 0; i < remainingCount; i++) {
 			var r = Math.random();
 			if (r < 0.3) {
 				enemiesToSpawnThisWave.push(Enemy);