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

/**** 
* Classes
****/ 
var Bullet = Container.expand(function (startX, startY, targetEnemy, damage, speed) {
	var self = Container.call(this);
	self.targetEnemy = targetEnemy;
	self.damage = damage || 10;
	self.speed = speed || 5;
	self.x = startX;
	self.y = startY;
	var bulletGraphics = self.attachAsset('bullet', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.update = function () {
		if (!self.targetEnemy || !self.targetEnemy.parent) {
			self.destroy();
			return;
		}
		var dx = self.targetEnemy.x - self.x;
		var dy = self.targetEnemy.y - self.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		if (distance < self.speed) {
			// Apply damage to target enemy
			self.targetEnemy.health -= self.damage;
			if (self.targetEnemy.health <= 0) {
				self.targetEnemy.health = 0;
			} else {
				self.targetEnemy.healthBar.width = self.targetEnemy.health / self.targetEnemy.maxHealth * 70;
			}
			// Apply special effects based on bullet type
			if (self.type === 'splash') {
				// Create visual splash effect
				var splashEffect = new EffectIndicator(self.targetEnemy.x, self.targetEnemy.y, 'splash');
				game.addChild(splashEffect);
				// Splash damage to nearby enemies
				var splashRadius = CELL_SIZE * 1.5;
				for (var i = 0; i < enemies.length; i++) {
					var otherEnemy = enemies[i];
					if (otherEnemy !== self.targetEnemy) {
						var splashDx = otherEnemy.x - self.targetEnemy.x;
						var splashDy = otherEnemy.y - self.targetEnemy.y;
						var splashDistance = Math.sqrt(splashDx * splashDx + splashDy * splashDy);
						if (splashDistance <= splashRadius) {
							// Apply splash damage (50% of original damage)
							otherEnemy.health -= self.damage * 0.5;
							if (otherEnemy.health <= 0) {
								otherEnemy.health = 0;
							} else {
								otherEnemy.healthBar.width = otherEnemy.health / otherEnemy.maxHealth * 70;
							}
						}
					}
				}
			} else if (self.type === 'slow') {
				// Prevent slow effect on immune enemies
				if (!self.targetEnemy.isImmune) {
					// Create visual slow effect
					var slowEffect = new EffectIndicator(self.targetEnemy.x, self.targetEnemy.y, 'slow');
					game.addChild(slowEffect);
					// Apply slow effect
					// Make slow percentage scale with tower level (default 50%, up to 80% at max level)
					var slowPct = 0.5;
					if (self.sourceTowerLevel !== undefined) {
						// Scale: 50% at level 1, 60% at 2, 65% at 3, 70% at 4, 75% at 5, 80% at 6
						var slowLevels = [0.5, 0.6, 0.65, 0.7, 0.75, 0.8];
						var idx = Math.max(0, Math.min(5, self.sourceTowerLevel - 1));
						slowPct = slowLevels[idx];
					}
					if (!self.targetEnemy.slowed) {
						self.targetEnemy.originalSpeed = self.targetEnemy.speed;
						self.targetEnemy.speed *= 1 - slowPct; // Slow by X%
						self.targetEnemy.slowed = true;
						self.targetEnemy.slowDuration = 180; // 3 seconds at 60 FPS
					} else {
						self.targetEnemy.slowDuration = 180; // Reset duration
					}
				}
			} else if (self.type === 'poison') {
				// Prevent poison effect on immune enemies
				if (!self.targetEnemy.isImmune) {
					// Create visual poison effect
					var poisonEffect = new EffectIndicator(self.targetEnemy.x, self.targetEnemy.y, 'poison');
					game.addChild(poisonEffect);
					// Apply poison effect
					self.targetEnemy.poisoned = true;
					self.targetEnemy.poisonDamage = self.damage * 0.2; // 20% of original damage per tick
					self.targetEnemy.poisonDuration = 300; // 5 seconds at 60 FPS
				}
			} else if (self.type === 'sniper') {
				// Create visual critical hit effect for sniper
				var sniperEffect = new EffectIndicator(self.targetEnemy.x, self.targetEnemy.y, 'sniper');
				game.addChild(sniperEffect);
			}
			self.destroy();
		} else {
			var angle = Math.atan2(dy, dx);
			self.x += Math.cos(angle) * self.speed;
			self.y += Math.sin(angle) * self.speed;
		}
	};
	return self;
});
var DebugCell = Container.expand(function () {
	var self = Container.call(this);
	var cellGraphics = self.attachAsset('cell', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	cellGraphics.tint = Math.random() * 0xffffff;
	var debugArrows = [];
	// Create white grid lines instead of numbers
	var gridLines = new Container();
	// Top line
	var topLine = gridLines.attachAsset('free', {
		anchorX: 0,
		anchorY: 0
	});
	topLine.width = CELL_SIZE;
	topLine.height = 2;
	topLine.tint = 0xFFFFFF;
	topLine.x = -CELL_SIZE / 2;
	topLine.y = -CELL_SIZE / 2;
	// Bottom line
	var bottomLine = gridLines.attachAsset('free', {
		anchorX: 0,
		anchorY: 0
	});
	bottomLine.width = CELL_SIZE;
	bottomLine.height = 2;
	bottomLine.tint = 0xFFFFFF;
	bottomLine.x = -CELL_SIZE / 2;
	bottomLine.y = CELL_SIZE / 2 - 2;
	// Left line
	var leftLine = gridLines.attachAsset('free', {
		anchorX: 0,
		anchorY: 0
	});
	leftLine.width = 2;
	leftLine.height = CELL_SIZE;
	leftLine.tint = 0xFFFFFF;
	leftLine.x = -CELL_SIZE / 2;
	leftLine.y = -CELL_SIZE / 2;
	// Right line
	var rightLine = gridLines.attachAsset('free', {
		anchorX: 0,
		anchorY: 0
	});
	rightLine.width = 2;
	rightLine.height = CELL_SIZE;
	rightLine.tint = 0xFFFFFF;
	rightLine.x = CELL_SIZE / 2 - 2;
	rightLine.y = -CELL_SIZE / 2;
	self.addChild(gridLines);
	// Add brown spawn markers
	var spawnMarkers = new Container();
	self.addChild(spawnMarkers);
	self.update = function () {};
	self.down = function () {
		return;
		if (self.cell.type == 0 || self.cell.type == 1) {
			self.cell.type = self.cell.type == 1 ? 0 : 1;
			if (grid.pathFind()) {
				self.cell.type = self.cell.type == 1 ? 0 : 1;
				grid.pathFind();
				var notification = game.addChild(new Notification("Path is blocked!"));
				notification.x = 2048 / 2;
				notification.y = grid.height - 50;
			}
			grid.renderDebug();
		}
	};
	self.removeArrows = function () {
		while (debugArrows.length) {
			self.removeChild(debugArrows.pop());
		}
	};
	self.render = function (data) {
		// Clear existing spawn markers
		while (spawnMarkers.children.length > 0) {
			spawnMarkers.removeChild(spawnMarkers.children[0]);
		}
		switch (data.type) {
			case 0:
			case 2:
				{
					if (data.pathId != pathId) {
						self.removeArrows();
						cellGraphics.tint = 0x880000;
						return;
					}
					var tint = Math.floor(data.score / maxScore * 0x88);
					var towerInRangeHighlight = false;
					if (selectedTower && data.towersInRange && data.towersInRange.indexOf(selectedTower) !== -1) {
						towerInRangeHighlight = true;
						cellGraphics.tint = 0x0088ff;
					} else {
						cellGraphics.tint = 0x88 - tint << 8 | tint;
					}
					// Add brown spawn marker for spawn cells (type 2)
					if (data.type === 2) {
						// Create thick brown border around spawn cells
						var spawnTopLine = spawnMarkers.attachAsset('brown', {
							anchorX: 0,
							anchorY: 0
						});
						spawnTopLine.width = CELL_SIZE;
						spawnTopLine.height = 8;
						spawnTopLine.tint = 0x8B4513; // Brown color
						spawnTopLine.x = -CELL_SIZE / 2;
						spawnTopLine.y = -CELL_SIZE / 2;
						var spawnBottomLine = spawnMarkers.attachAsset('free', {
							anchorX: 0,
							anchorY: 0
						});
						spawnBottomLine.width = CELL_SIZE;
						spawnBottomLine.height = 8;
						spawnBottomLine.tint = 0x8B4513; // Brown color
						spawnBottomLine.x = -CELL_SIZE / 2;
						spawnBottomLine.y = CELL_SIZE / 2 - 8;
						var spawnLeftLine = spawnMarkers.attachAsset('free', {
							anchorX: 0,
							anchorY: 0
						});
						spawnLeftLine.width = 8;
						spawnLeftLine.height = CELL_SIZE;
						spawnLeftLine.tint = 0x8B4513; // Brown color
						spawnLeftLine.x = -CELL_SIZE / 2;
						spawnLeftLine.y = -CELL_SIZE / 2;
						var spawnRightLine = spawnMarkers.attachAsset('free', {
							anchorX: 0,
							anchorY: 0
						});
						spawnRightLine.width = 8;
						spawnRightLine.height = CELL_SIZE;
						spawnRightLine.tint = 0x8B4513; // Brown color
						spawnRightLine.x = CELL_SIZE / 2 - 8;
						spawnRightLine.y = -CELL_SIZE / 2;
					}
					// Add brown connecting lines between top spawn point and bottom spawn point
					if (data.type === 2 && data.y === 0) {
						// This is a top spawn point, add vertical connecting line going down
						var connectingLine = spawnMarkers.attachAsset('free', {
							anchorX: 0.5,
							anchorY: 0
						});
						connectingLine.width = 8; // Make line thicker for better visibility
						connectingLine.height = CELL_SIZE * 34; // Extend height to reach all the way to bottom spawn area
						connectingLine.tint = 0x8B4513; // Brown color
						connectingLine.x = 0; // Center of cell
						connectingLine.y = CELL_SIZE / 2; // Start from bottom of current cell
						// Add horizontal brown line at top spawn point where arrows begin
						var horizontalLine = spawnMarkers.attachAsset('free', {
							anchorX: 0.5,
							anchorY: 0.5
						});
						horizontalLine.width = CELL_SIZE; // Full cell width
						horizontalLine.height = 8; // Same thickness as other brown lines
						horizontalLine.tint = 0x8B4513; // Brown color
						horizontalLine.x = 0; // Center of cell
						horizontalLine.y = -CELL_SIZE / 2; // Position at top of cell
					}
					while (debugArrows.length > data.targets.length) {
						self.removeChild(debugArrows.pop());
					}
					for (var a = 0; a < data.targets.length; a++) {
						var destination = data.targets[a];
						var ox = destination.x - data.x;
						var oy = destination.y - data.y;
						var angle = Math.atan2(oy, ox);
						if (!debugArrows[a]) {
							debugArrows[a] = LK.getAsset('arrow', {
								anchorX: -.5,
								anchorY: 0.5
							});
							debugArrows[a].alpha = .5;
							self.addChildAt(debugArrows[a], 1);
						}
						debugArrows[a].rotation = angle;
					}
					break;
				}
			case 1:
				{
					self.removeArrows();
					cellGraphics.tint = 0xaaaaaa;
					break;
				}
			case 3:
				{
					self.removeArrows();
					cellGraphics.tint = 0x008800;
					break;
				}
		}
	};
});
// This update method was incorrectly placed here and should be removed
var EffectIndicator = Container.expand(function (x, y, type) {
	var self = Container.call(this);
	self.x = x;
	self.y = y;
	var effectGraphics = self.attachAsset('rangeCircle', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	effectGraphics.blendMode = 1;
	switch (type) {
		case 'splash':
			effectGraphics.tint = 0x33CC00;
			effectGraphics.width = effectGraphics.height = CELL_SIZE * 1;
			break;
		case 'slow':
			effectGraphics.tint = 0x9900FF;
			effectGraphics.width = effectGraphics.height = CELL_SIZE;
			break;
		case 'poison':
			effectGraphics.tint = 0x00FFAA;
			effectGraphics.width = effectGraphics.height = CELL_SIZE;
			break;
		case 'sniper':
			effectGraphics.tint = 0xFF5500;
			effectGraphics.width = effectGraphics.height = CELL_SIZE;
			break;
	}
	effectGraphics.alpha = 0.7;
	self.alpha = 0;
	// Animate the effect
	tween(self, {
		alpha: 0.8,
		scaleX: 1.5,
		scaleY: 1.5
	}, {
		duration: 200,
		easing: tween.easeOut,
		onFinish: function onFinish() {
			tween(self, {
				alpha: 0,
				scaleX: 2,
				scaleY: 2
			}, {
				duration: 300,
				easing: tween.easeIn,
				onFinish: function onFinish() {
					self.destroy();
				}
			});
		}
	});
	return self;
});
// Base enemy class for common functionality
var Enemy = Container.expand(function (type) {
	var self = Container.call(this);
	self.type = type || 'normal';
	self.speed = .01;
	self.cellX = 0;
	self.cellY = 0;
	self.currentCellX = 0;
	self.currentCellY = 0;
	self.currentTarget = undefined;
	self.maxHealth = 100;
	self.health = self.maxHealth;
	self.bulletsTargetingThis = [];
	self.waveNumber = currentWave;
	self.isFlying = false;
	self.isImmune = false;
	self.isBoss = false;
	// Apply different stats based on enemy type
	switch (self.type) {
		case 'fast':
			self.speed *= 2; // Twice as fast
			self.maxHealth = 100;
			break;
		case 'immune':
			self.isImmune = true;
			self.maxHealth = 80;
			break;
		case 'flying':
			self.isFlying = true;
			self.maxHealth = 80;
			break;
		case 'swarm':
			self.maxHealth = 50; // Weaker enemies
			break;
		case 'normal':
		default:
			// Normal enemy uses default values
			break;
	}
	if (currentWave % 10 === 0 && currentWave > 0 && type !== 'swarm') {
		self.isBoss = true;
		// Boss enemies have 20x health and are larger
		self.maxHealth *= 20;
		// Slower speed for bosses
		self.speed = self.speed * 0.7;
	}
	self.health = self.maxHealth;
	if (typeof currentKingdom !== 'undefined') {
		var kingdomMultiplier = 1 + currentKingdom * 0.5; // Increased multiplier since no stages
		self.maxHealth = Math.round(self.maxHealth * kingdomMultiplier);
		self.health = self.maxHealth;
		self.speed *= 1 + currentKingdom * 0.15; // Increased speed scaling
	}
	// Get appropriate asset for this enemy type based on current kingdom
	var assetId = 'enemy';
	if (typeof currentKingdom !== 'undefined' && currentKingdom >= 0 && kingdomData[currentKingdom]) {
		var kingdomEnemies = kingdomData[currentKingdom].enemies;
		// Map enemy types to kingdom-specific assets
		switch (self.type) {
			case 'normal':
				assetId = kingdomEnemies[0];
				break;
			case 'fast':
				assetId = kingdomEnemies[1];
				break;
			case 'flying':
				assetId = kingdomEnemies[2];
				break;
			case 'immune':
				assetId = kingdomEnemies[3];
				break;
			case 'swarm':
				assetId = kingdomEnemies[4];
				break;
			default:
				assetId = kingdomEnemies[0];
				break;
		}
	} else {
		// Fallback to generic enemy assets if kingdom data not available
		if (self.type !== 'normal') {
			assetId = 'enemy_' + self.type;
		}
	}
	var enemyGraphics = self.attachAsset(assetId, {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Rotate elf assets by 90 degrees (except elf1 which should appear straight)
	if (assetId === 'elf2' || assetId === 'elf3' || assetId === 'elf4' || assetId === 'elf5') {
		enemyGraphics.rotation = Math.PI / 2; // 90 degrees in radians
	}
	// Scale up boss enemies
	if (self.isBoss) {
		enemyGraphics.scaleX = 1.8;
		enemyGraphics.scaleY = 1.8;
	}
	// Fall back to regular enemy asset if specific type asset not found
	// Apply tint to differentiate enemy types
	/*switch (self.type) {
		case 'fast':
			enemyGraphics.tint = 0x00AAFF; // Blue for fast enemies
			break;
		case 'immune':
			enemyGraphics.tint = 0xAA0000; // Red for immune enemies
			break;
		case 'flying':
			enemyGraphics.tint = 0xFFFF00; // Yellow for flying enemies
			break;
		case 'swarm':
			enemyGraphics.tint = 0xFF00FF; // Pink for swarm enemies
			break;
	}*/
	// Create shadow for flying enemies
	if (self.isFlying) {
		// Create a shadow container that will be added to the shadow layer
		self.shadow = new Container();
		// Clone the enemy graphics for the shadow
		var shadowGraphics = self.shadow.attachAsset(assetId || 'enemy', {
			anchorX: 0.5,
			anchorY: 0.5
		});
		// Apply shadow effect
		shadowGraphics.tint = 0x000000; // Black shadow
		shadowGraphics.alpha = 0.4; // Semi-transparent
		// If this is a boss, scale up the shadow to match
		if (self.isBoss) {
			shadowGraphics.scaleX = 1.8;
			shadowGraphics.scaleY = 1.8;
		}
		// Position shadow slightly offset
		self.shadow.x = 20; // Offset right
		self.shadow.y = 20; // Offset down
		// Ensure shadow has the same rotation as the enemy
		shadowGraphics.rotation = enemyGraphics.rotation;
	}
	var healthBarOutline = self.attachAsset('healthBarOutline', {
		anchorX: 0,
		anchorY: 0.5
	});
	var healthBarBG = self.attachAsset('healthBar', {
		anchorX: 0,
		anchorY: 0.5
	});
	var healthBar = self.attachAsset('healthBar', {
		anchorX: 0,
		anchorY: 0.5
	});
	healthBarBG.y = healthBarOutline.y = healthBar.y = -enemyGraphics.height / 2 - 10;
	healthBarOutline.x = -healthBarOutline.width / 2;
	healthBarBG.x = healthBar.x = -healthBar.width / 2 - .5;
	healthBar.tint = 0x00ff00;
	healthBarBG.tint = 0xff0000;
	self.healthBar = healthBar;
	self.update = function () {
		if (self.health <= 0) {
			self.health = 0;
			self.healthBar.width = 0;
		}
		// Handle slow effect
		if (self.isImmune) {
			// Immune enemies cannot be slowed or poisoned, clear any such effects
			self.slowed = false;
			self.slowEffect = false;
			self.poisoned = false;
			self.poisonEffect = false;
			// Reset speed to original if needed
			if (self.originalSpeed !== undefined) {
				self.speed = self.originalSpeed;
			}
		} else {
			// Handle slow effect
			if (self.slowed) {
				// Visual indication of slowed status
				if (!self.slowEffect) {
					self.slowEffect = true;
				}
				self.slowDuration--;
				if (self.slowDuration <= 0) {
					self.speed = self.originalSpeed;
					self.slowed = false;
					self.slowEffect = false;
					// Only reset tint if not poisoned
					if (!self.poisoned) {
						enemyGraphics.tint = 0xFFFFFF; // Reset tint
					}
				}
			}
			// Handle poison effect
			if (self.poisoned) {
				// Visual indication of poisoned status
				if (!self.poisonEffect) {
					self.poisonEffect = true;
				}
				// Apply poison damage every 30 frames (twice per second)
				if (LK.ticks % 30 === 0) {
					self.health -= self.poisonDamage;
					if (self.health <= 0) {
						self.health = 0;
					}
					self.healthBar.width = self.health / self.maxHealth * 70;
				}
				self.poisonDuration--;
				if (self.poisonDuration <= 0) {
					self.poisoned = false;
					self.poisonEffect = false;
					// Only reset tint if not slowed
					if (!self.slowed) {
						enemyGraphics.tint = 0xFFFFFF; // Reset tint
					}
				}
			}
		}
		// Set tint based on effect status
		if (self.isImmune) {
			enemyGraphics.tint = 0xFFFFFF;
		} else if (self.poisoned && self.slowed) {
			// Combine poison (0x00FFAA) and slow (0x9900FF) colors
			// Simple average: R: (0+153)/2=76, G: (255+0)/2=127, B: (170+255)/2=212
			enemyGraphics.tint = 0x4C7FD4;
		} else if (self.poisoned) {
			enemyGraphics.tint = 0x00FFAA;
		} else if (self.slowed) {
			enemyGraphics.tint = 0x9900FF;
		} else {
			enemyGraphics.tint = 0xFFFFFF;
		}
		if (self.currentTarget) {
			var ox = self.currentTarget.x - self.currentCellX;
			var oy = self.currentTarget.y - self.currentCellY;
			if (ox !== 0 || oy !== 0) {
				// Set enemy graphic to face downward (no rotation animation)
				enemyGraphics.rotation = 0;
			}
		}
		healthBarOutline.y = healthBarBG.y = healthBar.y = -enemyGraphics.height / 2 - 10;
	};
	return self;
});
var GoldIndicator = Container.expand(function (value, x, y) {
	var self = Container.call(this);
	var shadowText = new Text2("+" + value, {
		size: 45,
		fill: 0x000000,
		weight: 800
	});
	shadowText.anchor.set(0.5, 0.5);
	shadowText.x = 2;
	shadowText.y = 2;
	self.addChild(shadowText);
	var goldText = new Text2("+" + value, {
		size: 45,
		fill: 0xFFD700,
		weight: 800
	});
	goldText.anchor.set(0.5, 0.5);
	self.addChild(goldText);
	self.x = x;
	self.y = y;
	self.alpha = 0;
	self.scaleX = 0.5;
	self.scaleY = 0.5;
	tween(self, {
		alpha: 1,
		scaleX: 1.2,
		scaleY: 1.2,
		y: y - 40
	}, {
		duration: 50,
		easing: tween.easeOut,
		onFinish: function onFinish() {
			tween(self, {
				alpha: 0,
				scaleX: 1.5,
				scaleY: 1.5,
				y: y - 80
			}, {
				duration: 600,
				easing: tween.easeIn,
				delay: 800,
				onFinish: function onFinish() {
					self.destroy();
				}
			});
		}
	});
	return self;
});
var Grid = Container.expand(function (gridWidth, gridHeight) {
	var self = Container.call(this);
	self.cells = [];
	self.spawns = [];
	self.goals = [];
	for (var i = 0; i < gridWidth; i++) {
		self.cells[i] = [];
		for (var j = 0; j < gridHeight; j++) {
			self.cells[i][j] = {
				score: 0,
				pathId: 0,
				towersInRange: []
			};
		}
	}
	/*
				Cell Types
				0: Transparent floor
				1: Wall
				2: Spawn
				3: Goal
	*/
	for (var i = 0; i < gridWidth; i++) {
		for (var j = 0; j < gridHeight; j++) {
			var cell = self.cells[i][j];
			var cellType = i === 0 || i === gridWidth - 1 || j <= 4 || j >= gridHeight - 4 ? 1 : 0;
			if (i > 11 - 3 && i <= 11 + 3) {
				if (j === 0) {
					cellType = 2;
					self.spawns.push(cell);
				} else if (j <= 4) {
					cellType = 0;
				} else if (j === gridHeight - 1) {
					cellType = 3;
					self.goals.push(cell);
				} else if (j >= gridHeight - 4) {
					cellType = 0;
				}
			}
			cell.type = cellType;
			cell.x = i;
			cell.y = j;
			cell.upLeft = self.cells[i - 1] && self.cells[i - 1][j - 1];
			cell.up = self.cells[i - 1] && self.cells[i - 1][j];
			cell.upRight = self.cells[i - 1] && self.cells[i - 1][j + 1];
			cell.left = self.cells[i][j - 1];
			cell.right = self.cells[i][j + 1];
			cell.downLeft = self.cells[i + 1] && self.cells[i + 1][j - 1];
			cell.down = self.cells[i + 1] && self.cells[i + 1][j];
			cell.downRight = self.cells[i + 1] && self.cells[i + 1][j + 1];
			cell.neighbors = [cell.upLeft, cell.up, cell.upRight, cell.right, cell.downRight, cell.down, cell.downLeft, cell.left];
			cell.targets = [];
			if (j > 3 && j <= gridHeight - 4) {
				var debugCell = new DebugCell();
				self.addChild(debugCell);
				debugCell.cell = cell;
				debugCell.x = i * CELL_SIZE;
				debugCell.y = j * CELL_SIZE;
				cell.debugCell = debugCell;
			}
		}
	}
	self.getCell = function (x, y) {
		return self.cells[x] && self.cells[x][y];
	};
	self.pathFind = function () {
		var before = new Date().getTime();
		var toProcess = self.goals.concat([]);
		maxScore = 0;
		pathId += 1;
		for (var a = 0; a < toProcess.length; a++) {
			toProcess[a].pathId = pathId;
		}
		function processNode(node, targetValue, targetNode) {
			if (node && node.type != 1) {
				if (node.pathId < pathId || targetValue < node.score) {
					node.targets = [targetNode];
				} else if (node.pathId == pathId && targetValue == node.score) {
					node.targets.push(targetNode);
				}
				if (node.pathId < pathId || targetValue < node.score) {
					node.score = targetValue;
					if (node.pathId != pathId) {
						toProcess.push(node);
					}
					node.pathId = pathId;
					if (targetValue > maxScore) {
						maxScore = targetValue;
					}
				}
			}
		}
		while (toProcess.length) {
			var nodes = toProcess;
			toProcess = [];
			for (var a = 0; a < nodes.length; a++) {
				var node = nodes[a];
				var targetScore = node.score + 14142;
				if (node.up && node.left && node.up.type != 1 && node.left.type != 1) {
					processNode(node.upLeft, targetScore, node);
				}
				if (node.up && node.right && node.up.type != 1 && node.right.type != 1) {
					processNode(node.upRight, targetScore, node);
				}
				if (node.down && node.right && node.down.type != 1 && node.right.type != 1) {
					processNode(node.downRight, targetScore, node);
				}
				if (node.down && node.left && node.down.type != 1 && node.left.type != 1) {
					processNode(node.downLeft, targetScore, node);
				}
				targetScore = node.score + 10000;
				processNode(node.up, targetScore, node);
				processNode(node.right, targetScore, node);
				processNode(node.down, targetScore, node);
				processNode(node.left, targetScore, node);
			}
		}
		for (var a = 0; a < self.spawns.length; a++) {
			if (self.spawns[a].pathId != pathId) {
				console.warn("Spawn blocked");
				return true;
			}
		}
		for (var a = 0; a < enemies.length; a++) {
			var enemy = enemies[a];
			// Skip enemies that haven't entered the viewable area yet
			if (enemy.currentCellY < 4) {
				continue;
			}
			// Skip flying enemies from path check as they can fly over obstacles
			if (enemy.isFlying) {
				continue;
			}
			var target = self.getCell(enemy.cellX, enemy.cellY);
			if (enemy.currentTarget) {
				if (enemy.currentTarget.pathId != pathId) {
					if (!target || target.pathId != pathId) {
						console.warn("Enemy blocked 1 ");
						return true;
					}
				}
			} else if (!target || target.pathId != pathId) {
				console.warn("Enemy blocked 2");
				return true;
			}
		}
		console.log("Speed", new Date().getTime() - before);
	};
	self.renderDebug = function () {
		for (var i = 0; i < gridWidth; i++) {
			for (var j = 0; j < gridHeight; j++) {
				var debugCell = self.cells[i][j].debugCell;
				if (debugCell) {
					debugCell.render(self.cells[i][j]);
				}
			}
		}
	};
	self.updateEnemy = function (enemy) {
		var cell = grid.getCell(enemy.cellX, enemy.cellY);
		if (cell.type == 3) {
			return true;
		}
		// Update shadow position for flying enemies to match normal enemy movement
		if (enemy.isFlying && enemy.shadow) {
			enemy.shadow.x = enemy.x + 20; // Match enemy x-position + offset
			enemy.shadow.y = enemy.y + 20; // Match enemy y-position + offset
			// Match shadow rotation with enemy rotation
			if (enemy.children[0] && enemy.shadow.children[0]) {
				enemy.shadow.children[0].rotation = enemy.children[0].rotation;
			}
		}
		// Check if the enemy has reached the entry area (y position is at least 5)
		var hasReachedEntryArea = enemy.currentCellY >= 4;
		// If enemy hasn't reached the entry area yet, just move down vertically
		if (!hasReachedEntryArea) {
			// Move directly downward
			enemy.currentCellY += enemy.speed;
			// Set enemy graphic to face downward (no rotation animation)
			if (enemy.children[0]) {
				enemy.children[0].rotation = 0;
			}
			// Update enemy's position
			enemy.x = grid.x + enemy.currentCellX * CELL_SIZE;
			enemy.y = grid.y + enemy.currentCellY * CELL_SIZE;
			// If enemy has now reached the entry area, update cell coordinates
			if (enemy.currentCellY >= 4) {
				enemy.cellX = Math.round(enemy.currentCellX);
				enemy.cellY = Math.round(enemy.currentCellY);
			}
			return false;
		}
		// Handle normal pathfinding enemies (including flying enemies)
		// Handle normal pathfinding for all enemies (including flying enemies)
		if (!enemy.currentTarget) {
			enemy.currentTarget = cell.targets[0];
		}
		if (enemy.currentTarget) {
			if (cell.score < enemy.currentTarget.score) {
				enemy.currentTarget = cell;
			}
			var ox = enemy.currentTarget.x - enemy.currentCellX;
			var oy = enemy.currentTarget.y - enemy.currentCellY;
			var dist = Math.sqrt(ox * ox + oy * oy);
			if (dist < enemy.speed) {
				enemy.cellX = Math.round(enemy.currentCellX);
				enemy.cellY = Math.round(enemy.currentCellY);
				enemy.currentTarget = undefined;
				return;
			}
			var angle = Math.atan2(oy, ox);
			// Calculate next position
			var nextX = enemy.currentCellX + Math.cos(angle) * enemy.speed;
			var nextY = enemy.currentCellY + Math.sin(angle) * enemy.speed;
			// Check if next position would overlap with any tower (for all enemies, including flying)
			var canMove = true;
			// Check all towers for collision with next position
			for (var t = 0; t < towers.length; t++) {
				var tower = towers[t];
				// Check if enemy's next position would overlap with tower's 2x2 grid area
				var enemyGridX = Math.floor(nextX);
				var enemyGridY = Math.floor(nextY);
				// Also check current position to prevent enemies from getting stuck inside towers
				var currentEnemyGridX = Math.floor(enemy.currentCellX);
				var currentEnemyGridY = Math.floor(enemy.currentCellY);
				// Check both next position and current position for tower overlap
				var nextOverlap = enemyGridX >= tower.gridX && enemyGridX < tower.gridX + 2 && enemyGridY >= tower.gridY && enemyGridY < tower.gridY + 2;
				var currentOverlap = currentEnemyGridX >= tower.gridX && currentEnemyGridX < tower.gridX + 2 && currentEnemyGridY >= tower.gridY && currentEnemyGridY < tower.gridY + 2;
				if (nextOverlap && !currentOverlap) {
					canMove = false;
					break;
				}
			}
			// Move if path is clear
			if (canMove) {
				enemy.currentCellX = nextX;
				enemy.currentCellY = nextY;
			} else {
				// If blocked, try to find alternative path by checking adjacent cells
				var foundAlternative = false;
				// Calculate direction toward goal for prioritizing alternatives
				var goalDirection = Math.atan2(oy, ox);
				// Create movement alternatives with improved ordering
				var alternatives = [];
				// First priority: perpendicular movements away from obstacle
				var perpAngle1 = goalDirection + Math.PI / 2; // 90 degrees from goal direction
				var perpAngle2 = goalDirection - Math.PI / 2; // -90 degrees from goal direction
				alternatives.push({
					dx: Math.cos(perpAngle1) * enemy.speed,
					dy: Math.sin(perpAngle1) * enemy.speed
				});
				alternatives.push({
					dx: Math.cos(perpAngle2) * enemy.speed,
					dy: Math.sin(perpAngle2) * enemy.speed
				});
				// Second priority: backward movement to create space
				alternatives.push({
					dx: -Math.cos(goalDirection) * enemy.speed * 0.8,
					dy: -Math.sin(goalDirection) * enemy.speed * 0.8
				});
				// Third priority: cardinal directions
				alternatives.push({
					dx: 0,
					dy: -enemy.speed
				}); // Up
				alternatives.push({
					dx: 0,
					dy: enemy.speed
				}); // Down
				alternatives.push({
					dx: -enemy.speed,
					dy: 0
				}); // Left
				alternatives.push({
					dx: enemy.speed,
					dy: 0
				}); // Right
				// Fourth priority: diagonal movements for smoother navigation
				alternatives.push({
					dx: -enemy.speed * 0.7,
					dy: -enemy.speed * 0.7
				}); // Up-Left
				alternatives.push({
					dx: enemy.speed * 0.7,
					dy: -enemy.speed * 0.7
				}); // Up-Right
				alternatives.push({
					dx: -enemy.speed * 0.7,
					dy: enemy.speed * 0.7
				}); // Down-Left
				alternatives.push({
					dx: enemy.speed * 0.7,
					dy: enemy.speed * 0.7
				}); // Down-Right
				for (var alt = 0; alt < alternatives.length; alt++) {
					var altX = enemy.currentCellX + alternatives[alt].dx;
					var altY = enemy.currentCellY + alternatives[alt].dy;
					var altGridX = Math.floor(altX);
					var altGridY = Math.floor(altY);
					var altBlocked = false;
					// Check if alternative position is blocked by towers
					for (var t = 0; t < towers.length; t++) {
						var tower = towers[t];
						// Check current position to see if already inside tower
						var currentGridX = Math.floor(enemy.currentCellX);
						var currentGridY = Math.floor(enemy.currentCellY);
						var currentlyInside = currentGridX >= tower.gridX && currentGridX < tower.gridX + 2 && currentGridY >= tower.gridY && currentGridY < tower.gridY + 2;
						// Use more precise collision detection with buffer zone around towers
						var bufferZone = 0.1; // Small buffer to prevent getting stuck on edges
						var towerLeft = tower.gridX - bufferZone;
						var towerRight = tower.gridX + 2 + bufferZone;
						var towerTop = tower.gridY - bufferZone;
						var towerBottom = tower.gridY + 2 + bufferZone;
						if (altX >= towerLeft && altX < towerRight && altY >= towerTop && altY < towerBottom) {
							// If currently inside tower, allow movement that gets us further away
							if (currentlyInside) {
								var currentDist = Math.sqrt((enemy.currentCellX - (tower.gridX + 1)) * (enemy.currentCellX - (tower.gridX + 1)) + (enemy.currentCellY - (tower.gridY + 1)) * (enemy.currentCellY - (tower.gridY + 1)));
								var altDist = Math.sqrt((altX - (tower.gridX + 1)) * (altX - (tower.gridX + 1)) + (altY - (tower.gridY + 1)) * (altY - (tower.gridY + 1)));
								if (altDist <= currentDist) {
									altBlocked = true;
									break;
								}
							} else {
								altBlocked = true;
								break;
							}
						}
					}
					// Also check if alternative position is within valid grid bounds
					var cell = grid.getCell(altGridX, altGridY);
					if (!altBlocked && cell && cell.type !== 1 && altGridY >= 4) {
						enemy.currentCellX = altX;
						enemy.currentCellY = altY;
						foundAlternative = true;
						break;
					}
				}
				// If no alternative found, try very small movements to unstick
				if (!foundAlternative) {
					// Try tiny movements in all directions to escape being stuck
					var escapeRadius = enemy.speed * 0.2;
					var escapeAngles = [0, Math.PI / 4, Math.PI / 2, 3 * Math.PI / 4, Math.PI, 5 * Math.PI / 4, 3 * Math.PI / 2, 7 * Math.PI / 4];
					for (var angleIdx = 0; angleIdx < escapeAngles.length; angleIdx++) {
						var escapeAngle = escapeAngles[angleIdx];
						var escapeX = enemy.currentCellX + Math.cos(escapeAngle) * escapeRadius;
						var escapeY = enemy.currentCellY + Math.sin(escapeAngle) * escapeRadius;
						var escapeGridX = Math.floor(escapeX);
						var escapeGridY = Math.floor(escapeY);
						var escapeBlocked = false;
						for (var t = 0; t < towers.length; t++) {
							var tower = towers[t];
							if (escapeX >= tower.gridX && escapeX < tower.gridX + 2 && escapeY >= tower.gridY && escapeY < tower.gridY + 2) {
								escapeBlocked = true;
								break;
							}
						}
						var cell = grid.getCell(escapeGridX, escapeGridY);
						if (!escapeBlocked && cell && cell.type !== 1 && escapeGridY >= 4) {
							enemy.currentCellX = escapeX;
							enemy.currentCellY = escapeY;
							foundAlternative = true;
							break;
						}
					}
				}
			}
		}
		enemy.x = grid.x + enemy.currentCellX * CELL_SIZE;
		enemy.y = grid.y + enemy.currentCellY * CELL_SIZE;
	};
});
var InventoryScreen = Container.expand(function () {
	var self = Container.call(this);
	self.x = 2048 / 2;
	self.y = 2732 / 2;
	var backgroundOverlay = self.attachAsset('notification', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	backgroundOverlay.width = 2048;
	backgroundOverlay.height = 2732;
	backgroundOverlay.tint = 0x222222;
	backgroundOverlay.alpha = 0.95;
	var titleText = new Text2("Choose Your Warriors", {
		size: 100,
		fill: 0xFFD700,
		weight: 800
	});
	titleText.anchor.set(0.5, 0.5);
	titleText.y = -600;
	self.addChild(titleText);
	var kingdomName = kingdomData[currentKingdom] && kingdomData[currentKingdom].name ? kingdomData[currentKingdom].name : "Unknown";
	var progressText = new Text2("Kingdom " + (currentKingdom + 1) + " of 7: " + kingdomName, {
		size: 80,
		fill: 0xFFFFFF,
		weight: 600
	});
	progressText.anchor.set(0.5, 0.5);
	progressText.y = -450;
	self.addChild(progressText);
	var charactersContainer = new Container();
	charactersContainer.y = -50;
	self.addChild(charactersContainer);
	var towerTypes = ['Human Archer', 'Cannon Soldier', 'Catapult of Selena', 'Lightning Mage', 'Frost Blaster', 'Poison Archer'];
	var towerNames = ['Human Archer', 'Cannon Soldier', 'Catapult of Selena', 'Lightning Mage', 'Frost Blaster', 'Poison Archer'];
	for (var i = 0; i < 6; i++) {
		var characterSlot = new Container();
		var slotBg = characterSlot.attachAsset('notification', {
			anchorX: 0.5,
			anchorY: 0.5
		});
		slotBg.width = 300;
		slotBg.height = 400;
		slotBg.tint = 0x444444;
		var activeCharacter = getActiveCharacter(towerTypes[i]);
		var characterName = activeCharacter ? activeCharacter.name : towerNames[i];
		var nameText = new Text2(characterName, {
			size: 50,
			fill: 0xFFFFFF,
			weight: 600
		});
		nameText.anchor.set(0.5, 0.5);
		nameText.y = -150;
		characterSlot.addChild(nameText);
		// Get appropriate character asset based on kingdom and tower type
		var characterAsset = 'defense'; // Default asset
		if (typeof currentKingdom !== 'undefined' && currentKingdom >= 0 && kingdomData[currentKingdom]) {
			var kingdomTowers = kingdomData[currentKingdom].towers;
			var towerTypeMap = {
				'Human Archer': 'default',
				'Cannon Soldier': 'rapid',
				'Catapult of Selena': 'sniper',
				'Lightning Mage': 'splash',
				'Frost Blaster': 'slow',
				'Poison Archer': 'poison'
			};
			var mappedType = towerTypeMap[towerTypes[i]] || 'default';
			// Find the tower definition for this slot in the current kingdom
			var towerDef = null;
			for (var j = 0; j < kingdomTowers.length; j++) {
				if (kingdomTowers[j].type === mappedType) {
					towerDef = kingdomTowers[j];
					break;
				}
			}
			if (towerDef) {
				characterAsset = towerDef.asset;
			} else {
				// Fallback to character-based selection
				if (activeCharacter) {
					if (activeCharacter.name === 'Human Archer') {
						characterAsset = 'defense';
					} else if (activeCharacter.name === 'Elf Archer') {
						characterAsset = 'elf1';
					} else if (activeCharacter.name === 'Cannon Soldier') {
						characterAsset = 'cannon';
					} else if (activeCharacter.name === 'Catapult of Selena') {
						characterAsset = 'selena';
					} else if (activeCharacter.name === 'Lightning Mage') {
						characterAsset = 'lightingmage';
					} else if (activeCharacter.name === 'Frost Blaster') {
						characterAsset = 'frost';
					} else if (activeCharacter.name === 'Poison Archer') {
						characterAsset = 'poisonarcher';
					}
				}
			}
		} else {
			// Fallback to original logic when kingdom data not available
			if (activeCharacter) {
				if (activeCharacter.name === 'Human Archer') {
					characterAsset = 'defense';
				} else if (activeCharacter.name === 'Elf Archer') {
					characterAsset = 'elf1';
				} else if (activeCharacter.name === 'Cannon Soldier') {
					characterAsset = 'cannon';
				} else if (activeCharacter.name === 'Catapult of Selena') {
					characterAsset = 'selena';
				} else if (activeCharacter.name === 'Lightning Mage') {
					characterAsset = 'lightingmage';
				} else if (activeCharacter.name === 'Frost Blaster') {
					characterAsset = 'frost';
				} else if (activeCharacter.name === 'Poison Archer') {
					characterAsset = 'poisonarcher';
				}
			} else {
				// Fallback based on tower type
				switch (towerTypes[i]) {
					case 'Human Archer':
						characterAsset = 'defense';
						break;
					case 'Cannon Soldier':
						characterAsset = 'cannon';
						break;
					case 'Catapult of Selena':
						characterAsset = 'selena';
						break;
					case 'Lightning Mage':
						characterAsset = 'lightingmage';
						break;
					case 'Frost Blaster':
						characterAsset = 'frost';
						break;
					case 'Poison Archer':
						characterAsset = 'poisonarcher';
						break;
				}
			}
		}
		var towerPreview = characterSlot.attachAsset(characterAsset, {
			anchorX: 0.5,
			anchorY: 0.5
		});
		towerPreview.width = 120;
		towerPreview.height = 120;
		// Color assignment removed - characters use their natural asset colors
		towerPreview.y = -50;
		var costText = new Text2("Cost: " + getTowerCost(towerTypes[i], activeCharacter), {
			size: 40,
			fill: 0xFFD700,
			weight: 600
		});
		costText.anchor.set(0.5, 0.5);
		costText.y = 50;
		characterSlot.addChild(costText);
		if (unlockedCharacters[towerTypes[i]] && unlockedCharacters[towerTypes[i]].length > 1) {
			var switchButton = new Container();
			var switchBg = switchButton.attachAsset('notification', {
				anchorX: 0.5,
				anchorY: 0.5
			});
			switchBg.width = 200;
			switchBg.height = 60;
			switchBg.tint = 0x0088FF;
			var switchText = new Text2("Switch", {
				size: 40,
				fill: 0xFFFFFF,
				weight: 600
			});
			switchText.anchor.set(0.5, 0.5);
			switchButton.addChild(switchText);
			switchButton.y = 130;
			characterSlot.addChild(switchButton);
			switchButton.towerType = towerTypes[i];
			switchButton.down = function () {
				switchCharacter(this.towerType);
				self.destroy();
				gameState = 'inventory';
			};
		}
		characterSlot.x = i % 3 * 350 - 350;
		characterSlot.y = Math.floor(i / 3) * 450;
		charactersContainer.addChild(characterSlot);
	}
	var continueButton = new Container();
	var continueBg = continueButton.attachAsset('notification', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	continueBg.width = 400;
	continueBg.height = 120;
	continueBg.tint = 0x00AA00;
	var continueText = new Text2("Continue Battle", {
		size: 60,
		fill: 0xFFFFFF,
		weight: 800
	});
	continueText.anchor.set(0.5, 0.5);
	continueButton.addChild(continueText);
	continueButton.y = 400;
	self.addChild(continueButton);
	continueButton.down = function () {
		gameState = 'playing';
		self.destroy();
	};
	return self;
});
var NextWaveButton = Container.expand(function () {
	var self = Container.call(this);
	var buttonBackground = self.attachAsset('notification', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	buttonBackground.width = 300;
	buttonBackground.height = 100;
	buttonBackground.tint = 0x0088FF;
	var buttonText = new Text2("Next Wave", {
		size: 50,
		fill: 0xFFFFFF,
		weight: 800
	});
	buttonText.anchor.set(0.5, 0.5);
	self.addChild(buttonText);
	self.enabled = false;
	self.visible = false;
	self.update = function () {
		if (waveIndicator && waveIndicator.gameStarted && currentWave < totalWaves) {
			self.enabled = true;
			self.visible = true;
			buttonBackground.tint = 0x0088FF;
			self.alpha = 1;
		} else {
			self.enabled = false;
			self.visible = false;
			buttonBackground.tint = 0x888888;
			self.alpha = 0.7;
		}
	};
	self.down = function () {
		if (!self.enabled) {
			return;
		}
		if (waveIndicator.gameStarted && currentWave < totalWaves) {
			currentWave++; // Increment to the next wave directly
			waveTimer = 0; // Reset wave timer
			waveInProgress = true;
			waveSpawned = false;
			// Get the type of the current wave (which is now the next wave)
			var waveType = waveIndicator.getWaveTypeName(currentWave);
			var enemyCount = waveIndicator.getEnemyCount(currentWave);
			var notification = game.addChild(new Notification("Wave " + currentWave + " (" + waveType + " - " + enemyCount + " enemies) activated!"));
			notification.x = 2048 / 2;
			notification.y = grid.height - 150;
		}
	};
	return self;
});
var Notification = Container.expand(function (message) {
	var self = Container.call(this);
	var notificationGraphics = self.attachAsset('notification', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	var notificationText = new Text2(message, {
		size: 50,
		fill: 0x000000,
		weight: 800
	});
	notificationText.anchor.set(0.5, 0.5);
	notificationGraphics.width = notificationText.width + 30;
	self.addChild(notificationText);
	self.alpha = 1;
	var fadeOutTime = 120;
	self.update = function () {
		if (fadeOutTime > 0) {
			fadeOutTime--;
			self.alpha = Math.min(fadeOutTime / 120 * 2, 1);
		} else {
			self.destroy();
		}
	};
	return self;
});
var SourceTower = Container.expand(function (towerType) {
	var self = Container.call(this);
	self.towerType = towerType || 'default';
	// Map tower types to specific assets
	var assetName = 'defense'; // default
	switch (towerType) {
		case 'default':
			assetName = 'defense';
			break;
		case 'rapid':
			assetName = 'cannon';
			break;
		case 'sniper':
			assetName = 'selena';
			break;
		case 'splash':
			assetName = 'lightingmage';
			break;
		case 'slow':
			assetName = 'frost';
			break;
		case 'poison':
			assetName = 'poisonarcher';
			break;
	}
	// Increase size of base for easier touch
	var baseGraphics = self.attachAsset(assetName, {
		anchorX: 0.5,
		anchorY: 0.5,
		scaleX: 1.3,
		scaleY: 1.3
	});
	// Color assignment removed - characters use their natural asset colors
	var towerCost = getTowerCost(self.towerType);
	// Add shadow for tower type label
	var typeLabelShadow = new Text2(self.towerType.charAt(0).toUpperCase() + self.towerType.slice(1), {
		size: 50,
		fill: 0x000000,
		weight: 800
	});
	typeLabelShadow.anchor.set(0.5, 0.5);
	typeLabelShadow.x = 4;
	typeLabelShadow.y = -20 + 4;
	self.addChild(typeLabelShadow);
	// Add tower type label
	var activeChar = getActiveCharacter(self.towerType);
	var displayName = activeChar ? activeChar.name : self.towerType === 'default' ? 'Human Archer' : self.towerType === 'sniper' ? 'Catapult of Selena' : self.towerType.charAt(0).toUpperCase() + self.towerType.slice(1);
	// Ensure Human Archer is displayed correctly for default tower type
	if (self.towerType === 'default' && displayName !== 'Human Archer') {
		displayName = 'Human Archer';
	}
	var typeLabel = new Text2(displayName, {
		size: 40,
		fill: 0xFFFFFF,
		weight: 800
	});
	typeLabel.anchor.set(0.5, 0.5);
	typeLabel.y = -20; // Position above center of tower
	self.addChild(typeLabel);
	// Add cost shadow
	var costLabelShadow = new Text2(towerCost, {
		size: 50,
		fill: 0x000000,
		weight: 800
	});
	costLabelShadow.anchor.set(0.5, 0.5);
	costLabelShadow.x = 4;
	costLabelShadow.y = 24 + 12;
	self.addChild(costLabelShadow);
	// Add cost label
	var costLabel = new Text2(towerCost, {
		size: 50,
		fill: 0xFFD700,
		weight: 800
	});
	costLabel.anchor.set(0.5, 0.5);
	costLabel.y = 20 + 12;
	self.addChild(costLabel);
	self.update = function () {
		// Check if player can afford this tower
		var canAfford = gold >= getTowerCost(self.towerType);
		// Set opacity based on affordability
		self.alpha = canAfford ? 1 : 0.5;
	};
	return self;
});
var StoryScreen = Container.expand(function () {
	var self = Container.call(this);
	self.x = 2048 / 2;
	self.y = 2732 / 2;
	var backgroundOverlay = self.attachAsset('notification', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	backgroundOverlay.width = 2048;
	backgroundOverlay.height = 2732;
	backgroundOverlay.tint = 0x000000;
	backgroundOverlay.alpha = 0.9;
	var titleText = new Text2("The War of Seven Kingdoms", {
		size: 120,
		fill: 0xFFD700,
		weight: 800
	});
	titleText.anchor.set(0.5, 0.5);
	titleText.y = -400;
	self.addChild(titleText);
	var storyText = new Text2("Long ago, the Human Kingdom ruled in peace.\n\nBut dark times have come. Six enemy kingdoms\nhave united to invade our lands:\n\n• The Elf Kingdom from the eastern forests\n• The Goblin Clans from the northern mountains\n• The Hawk Eye Tribe from the sky realm\n• The Dragon Empire from the fire lands\n• The Shadow Tribe from the void\n• The Dark Bloom Kingdom from the poisoned swamps\n• The Undead Kingdom from the realm of death\n\nAs the last defender of the Human Kingdom,\nyou must use your towers to stop their advance.\n\nDefeat each kingdom to unlock their warriors\nfor your own army!", {
		size: 60,
		fill: 0xFFFFFF,
		weight: 400
	});
	storyText.anchor.set(0.5, 0.5);
	storyText.y = 0;
	self.addChild(storyText);
	var startButton = new Container();
	var startButtonBg = startButton.attachAsset('notification', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	startButtonBg.width = 600;
	startButtonBg.height = 150;
	startButtonBg.tint = 0x00AA00;
	var startButtonText = new Text2("Begin Your Defense", {
		size: 80,
		fill: 0xFFFFFF,
		weight: 800
	});
	startButtonText.anchor.set(0.5, 0.5);
	startButton.addChild(startButtonText);
	startButton.y = 400;
	self.addChild(startButton);
	startButton.down = function () {
		gameState = 'playing';
		self.destroy();
	};
	return self;
});
var Tower = Container.expand(function (id) {
	var self = Container.call(this);
	self.id = id || 'default';
	self.level = 1;
	self.maxLevel = 6;
	self.gridX = 0;
	self.gridY = 0;
	self.range = 3 * CELL_SIZE;
	self.character = getActiveCharacter(id);
	// Standardized method to get the current range of the tower
	self.getRange = function () {
		// Always calculate range based on tower type and level
		switch (self.id) {
			case 'Catapult of Selena':
				// Catapult of Selena: base 5, +0.8 per level, but final upgrade gets a huge boost
				if (self.level === self.maxLevel) {
					return 12 * CELL_SIZE; // Significantly increased range for max level
				}
				return (5 + (self.level - 1) * 0.8) * CELL_SIZE;
			case 'Lightning Mage':
				// Lightning Mage: base 2, +0.2 per level (max ~4 blocks at max level)
				return (2 + (self.level - 1) * 0.2) * CELL_SIZE;
			case 'Cannon Soldier':
				// Cannon Soldier: base 2.5, +0.5 per level
				return (2.5 + (self.level - 1) * 0.5) * CELL_SIZE;
			case 'Frost Blaster':
				// Frost Blaster: base 3.5, +0.5 per level
				return (3.5 + (self.level - 1) * 0.5) * CELL_SIZE;
			case 'Poison Archer':
				// Poison Archer: base 3.2, +0.5 per level
				return (3.2 + (self.level - 1) * 0.5) * CELL_SIZE;
			default:
				// Human Archer: base 3, +0.5 per level
				return (3 + (self.level - 1) * 0.5) * CELL_SIZE;
		}
	};
	self.cellsInRange = [];
	self.fireRate = 60;
	self.bulletSpeed = 5;
	self.damage = 10;
	self.lastFired = 0;
	self.targetEnemy = null;
	switch (self.id) {
		case 'Cannon Soldier':
			self.fireRate = 30;
			self.damage = 7;
			self.range = 2.5 * CELL_SIZE;
			self.bulletSpeed = 7;
			break;
		case 'Catapult of Selena':
			self.fireRate = 120;
			self.damage = 15;
			self.range = 5 * CELL_SIZE;
			self.bulletSpeed = 25;
			break;
		case 'Lightning Mage':
			self.fireRate = 60;
			self.damage = 8;
			self.range = 2 * CELL_SIZE;
			self.bulletSpeed = 4;
			break;
		case 'Frost Blaster':
			self.fireRate = 60;
			self.damage = 5;
			self.range = 3.5 * CELL_SIZE;
			self.bulletSpeed = 5;
			break;
		case 'Poison Archer':
			self.fireRate = 60;
			self.damage = 6;
			self.range = 3.2 * CELL_SIZE;
			self.bulletSpeed = 5;
			break;
	}
	if (self.character) {
		self.damage = Math.round(self.damage * self.character.damage);
		self.fireRate = Math.round(self.fireRate / self.character.fireRate);
		if (self.character.range) {
			self.range *= self.character.range;
		}
	}
	// Use kingdom-based assets for tower characters
	var assetName = 'defense'; // Default asset
	if (typeof currentKingdom !== 'undefined' && currentKingdom >= 0 && kingdomData[currentKingdom]) {
		var kingdomTowers = kingdomData[currentKingdom].towers;
		// Find the tower definition that matches this tower's type
		var towerDef = null;
		var towerTypeMap = {
			'default': 'default',
			'rapid': 'rapid',
			'sniper': 'sniper',
			'splash': 'splash',
			'slow': 'slow',
			'poison': 'poison'
		};
		var mappedType = towerTypeMap[self.id] || self.id;
		for (var i = 0; i < kingdomTowers.length; i++) {
			if (kingdomTowers[i].type === mappedType) {
				towerDef = kingdomTowers[i];
				break;
			}
		}
		if (towerDef) {
			assetName = towerDef.asset;
		} else {
			// Fallback to original logic if no kingdom definition found
			if (self.character && self.character.name === 'Cannon Soldier') {
				assetName = 'cannon';
			} else if (self.character && self.character.name === 'Catapult of Selena') {
				assetName = 'selena';
			} else if (self.character && self.character.name === 'Human Archer') {
				assetName = 'defense';
			} else if (self.character && self.character.name === 'Elf Archer') {
				assetName = 'elf1';
			} else if (self.character && self.character.name === 'Lightning Mage') {
				assetName = 'lightingmage';
			} else if (self.character && self.character.name === 'Frost Blaster') {
				assetName = 'frost';
			} else if (self.character && self.character.name === 'Poison Archer') {
				assetName = 'poisonarcher';
			}
		}
	} else {
		// Fallback to original character-based logic
		if (self.character && self.character.name === 'Cannon Soldier') {
			assetName = 'cannon';
		} else if (self.character && self.character.name === 'Catapult of Selena') {
			assetName = 'selena';
		} else if (self.character && self.character.name === 'Human Archer') {
			assetName = 'defense';
		} else if (self.character && self.character.name === 'Elf Archer') {
			assetName = 'elf1';
		} else if (self.character && self.character.name === 'Lightning Mage') {
			assetName = 'lightingmage';
		} else if (self.character && self.character.name === 'Frost Blaster') {
			assetName = 'frost';
		} else if (self.character && self.character.name === 'Poison Archer') {
			assetName = 'poisonarcher';
		} else if (self.id === 'default' || self.id === 'Human Archer') {
			assetName = 'defense';
		} else if (self.id === 'splash') {
			assetName = 'lightingmage';
		}
	}
	var baseGraphics = self.attachAsset(assetName, {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Adjust hitbox for special assets to better match visible area
	if (assetName === 'cannon' || assetName === 'selena' || assetName === 'defense' || assetName === 'lightingmage' || assetName === 'frost' || assetName === 'poisonarcher') {
		// Use helper function to get tight bounds for special assets
		getNonTransparentBounds(baseGraphics, function (bounds) {
			// Set interactive area based on calculated bounds
			baseGraphics.hitArea = {
				x: bounds.x - baseGraphics.width / 2,
				y: bounds.y - baseGraphics.height / 2,
				width: bounds.width,
				height: bounds.height
			};
		});
	}
	// Color assignment removed - characters use their natural asset colors
	var levelIndicators = [];
	var maxDots = self.maxLevel;
	var dotSpacing = baseGraphics.width / (maxDots + 1);
	var dotSize = CELL_SIZE / 6;
	for (var i = 0; i < maxDots; i++) {
		var dot = new Container();
		var outlineCircle = dot.attachAsset('towerLevelIndicator', {
			anchorX: 0.5,
			anchorY: 0.5
		});
		outlineCircle.width = dotSize + 4;
		outlineCircle.height = dotSize + 4;
		outlineCircle.tint = 0x000000;
		var towerLevelIndicator = dot.attachAsset('towerLevelIndicator', {
			anchorX: 0.5,
			anchorY: 0.5
		});
		towerLevelIndicator.width = dotSize;
		towerLevelIndicator.height = dotSize;
		towerLevelIndicator.tint = 0xCCCCCC;
		dot.x = -CELL_SIZE + dotSpacing * (i + 1);
		dot.y = CELL_SIZE * 0.7;
		self.addChild(dot);
		levelIndicators.push(dot);
	}
	var gunContainer = new Container();
	self.addChild(gunContainer);
	var gunGraphics = gunContainer.attachAsset('free', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.updateLevelIndicators = function () {
		for (var i = 0; i < maxDots; i++) {
			var dot = levelIndicators[i];
			var towerLevelIndicator = dot.children[1];
			if (i < self.level) {
				towerLevelIndicator.tint = 0xFFFFFF;
			} else {
				towerLevelIndicator.tint = 0xCCCCCC;
			}
		}
	};
	self.updateLevelIndicators();
	self.refreshCellsInRange = function () {
		for (var i = 0; i < self.cellsInRange.length; i++) {
			var cell = self.cellsInRange[i];
			var towerIndex = cell.towersInRange.indexOf(self);
			if (towerIndex !== -1) {
				cell.towersInRange.splice(towerIndex, 1);
			}
		}
		self.cellsInRange = [];
		var rangeRadius = self.getRange() / CELL_SIZE;
		var centerX = self.gridX + 1;
		var centerY = self.gridY + 1;
		var minI = Math.floor(centerX - rangeRadius - 0.5);
		var maxI = Math.ceil(centerX + rangeRadius + 0.5);
		var minJ = Math.floor(centerY - rangeRadius - 0.5);
		var maxJ = Math.ceil(centerY + rangeRadius + 0.5);
		for (var i = minI; i <= maxI; i++) {
			for (var j = minJ; j <= maxJ; j++) {
				var closestX = Math.max(i, Math.min(centerX, i + 1));
				var closestY = Math.max(j, Math.min(centerY, j + 1));
				var deltaX = closestX - centerX;
				var deltaY = closestY - centerY;
				var distanceSquared = deltaX * deltaX + deltaY * deltaY;
				if (distanceSquared <= rangeRadius * rangeRadius) {
					var cell = grid.getCell(i, j);
					if (cell) {
						self.cellsInRange.push(cell);
						cell.towersInRange.push(self);
					}
				}
			}
		}
		grid.renderDebug();
	};
	self.getTotalValue = function () {
		var baseTowerCost = getTowerCost(self.id);
		var totalInvestment = baseTowerCost;
		var baseUpgradeCost = baseTowerCost; // Upgrade cost now scales with base tower cost
		for (var i = 1; i < self.level; i++) {
			totalInvestment += Math.floor(baseUpgradeCost * Math.pow(2, i - 1));
		}
		return totalInvestment;
	};
	self.upgrade = function () {
		if (self.level < self.maxLevel) {
			// Exponential upgrade cost: base cost * (2 ^ (level-1)), scaled by tower base cost
			var baseUpgradeCost = getTowerCost(self.id);
			var upgradeCost;
			// Make last upgrade level extra expensive
			if (self.level === self.maxLevel - 1) {
				upgradeCost = Math.floor(baseUpgradeCost * Math.pow(2, self.level - 1) * 3.5 / 2); // Half the cost for final upgrade
			} else {
				upgradeCost = Math.floor(baseUpgradeCost * Math.pow(2, self.level - 1));
			}
			if (gold >= upgradeCost) {
				setGold(gold - upgradeCost);
				self.level++;
				// No need to update self.range here; getRange() is now the source of truth
				// Apply tower-specific upgrades based on type
				if (self.id === 'rapid') {
					if (self.level === self.maxLevel) {
						// Extra powerful last upgrade (double the effect)
						self.fireRate = Math.max(4, 30 - self.level * 9); // double the effect
						self.damage = 5 + self.level * 10; // double the effect
						self.bulletSpeed = 7 + self.level * 2.4; // double the effect
					} else {
						self.fireRate = Math.max(15, 30 - self.level * 3); // Fast tower gets faster with upgrades
						self.damage = 5 + self.level * 3;
						self.bulletSpeed = 7 + self.level * 0.7;
					}
				} else {
					if (self.level === self.maxLevel) {
						// Extra powerful last upgrade for all other towers (double the effect)
						self.fireRate = Math.max(5, 60 - self.level * 24); // double the effect
						self.damage = 10 + self.level * 20; // double the effect
						self.bulletSpeed = 5 + self.level * 2.4; // double the effect
					} else {
						self.fireRate = Math.max(20, 60 - self.level * 8);
						self.damage = 10 + self.level * 5;
						self.bulletSpeed = 5 + self.level * 0.5;
					}
				}
				self.refreshCellsInRange();
				self.updateLevelIndicators();
				if (self.level > 1) {
					var levelDot = levelIndicators[self.level - 1].children[1];
					tween(levelDot, {
						scaleX: 1.5,
						scaleY: 1.5
					}, {
						duration: 300,
						easing: tween.elasticOut,
						onFinish: function onFinish() {
							tween(levelDot, {
								scaleX: 1,
								scaleY: 1
							}, {
								duration: 200,
								easing: tween.easeOut
							});
						}
					});
				}
				return true;
			} else {
				var notification = game.addChild(new Notification("Not enough gold to upgrade!"));
				notification.x = 2048 / 2;
				notification.y = grid.height - 50;
				return false;
			}
		}
		return false;
	};
	self.findTarget = function () {
		var closestEnemy = null;
		var closestScore = Infinity;
		for (var i = 0; i < enemies.length; i++) {
			var enemy = enemies[i];
			var dx = enemy.x - self.x;
			var dy = enemy.y - self.y;
			var distance = Math.sqrt(dx * dx + dy * dy);
			// Check if enemy is in range
			if (distance <= self.getRange()) {
				// Handle flying enemies differently - they can be targeted regardless of path
				if (enemy.isFlying) {
					// For flying enemies, prioritize by distance to the goal
					if (enemy.flyingTarget) {
						var goalX = enemy.flyingTarget.x;
						var goalY = enemy.flyingTarget.y;
						var distToGoal = Math.sqrt((goalX - enemy.cellX) * (goalX - enemy.cellX) + (goalY - enemy.cellY) * (goalY - enemy.cellY));
						// Use distance to goal as score
						if (distToGoal < closestScore) {
							closestScore = distToGoal;
							closestEnemy = enemy;
						}
					} else {
						// If no flying target yet (shouldn't happen), prioritize by distance to tower
						if (distance < closestScore) {
							closestScore = distance;
							closestEnemy = enemy;
						}
					}
				} else {
					// For ground enemies, use the original path-based targeting
					// Get the cell for this enemy
					var cell = grid.getCell(enemy.cellX, enemy.cellY);
					if (cell && cell.pathId === pathId) {
						// Use the cell's score (distance to exit) for prioritization
						// Lower score means closer to exit
						if (cell.score < closestScore) {
							closestScore = cell.score;
							closestEnemy = enemy;
						}
					}
				}
			}
		}
		if (!closestEnemy) {
			self.targetEnemy = null;
		}
		return closestEnemy;
	};
	self.update = function () {
		self.targetEnemy = self.findTarget();
		if (self.targetEnemy) {
			var dx = self.targetEnemy.x - self.x;
			var dy = self.targetEnemy.y - self.y;
			var angle = Math.atan2(dy, dx);
			gunContainer.rotation = angle;
			if (LK.ticks - self.lastFired >= self.fireRate) {
				self.fire();
				self.lastFired = LK.ticks;
			}
		}
	};
	self.down = function (x, y, obj) {
		var existingMenus = game.children.filter(function (child) {
			return child instanceof UpgradeMenu;
		});
		var hasOwnMenu = false;
		var rangeCircle = null;
		for (var i = 0; i < game.children.length; i++) {
			if (game.children[i].isTowerRange && game.children[i].tower === self) {
				rangeCircle = game.children[i];
				break;
			}
		}
		for (var i = 0; i < existingMenus.length; i++) {
			if (existingMenus[i].tower === self) {
				hasOwnMenu = true;
				break;
			}
		}
		if (hasOwnMenu) {
			for (var i = 0; i < existingMenus.length; i++) {
				if (existingMenus[i].tower === self) {
					hideUpgradeMenu(existingMenus[i]);
				}
			}
			if (rangeCircle) {
				game.removeChild(rangeCircle);
			}
			selectedTower = null;
			grid.renderDebug();
			return;
		}
		for (var i = 0; i < existingMenus.length; i++) {
			existingMenus[i].destroy();
		}
		for (var i = game.children.length - 1; i >= 0; i--) {
			if (game.children[i].isTowerRange) {
				game.removeChild(game.children[i]);
			}
		}
		selectedTower = self;
		var rangeIndicator = new Container();
		rangeIndicator.isTowerRange = true;
		rangeIndicator.tower = self;
		game.addChild(rangeIndicator);
		rangeIndicator.x = self.x;
		rangeIndicator.y = self.y;
		var rangeGraphics = rangeIndicator.attachAsset('rangeCircle', {
			anchorX: 0.5,
			anchorY: 0.5
		});
		rangeGraphics.width = rangeGraphics.height = self.getRange() * 1;
		rangeGraphics.alpha = 0.3;
		var upgradeMenu = new UpgradeMenu(self);
		game.addChild(upgradeMenu);
		upgradeMenu.x = 2048 / 2;
		tween(upgradeMenu, {
			y: 2732 - 225
		}, {
			duration: 200,
			easing: tween.backOut
		});
		grid.renderDebug();
	};
	self.isInRange = function (enemy) {
		if (!enemy) {
			return false;
		}
		var dx = enemy.x - self.x;
		var dy = enemy.y - self.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		return distance <= self.getRange();
	};
	self.fire = function () {
		if (self.targetEnemy) {
			var potentialDamage = 0;
			for (var i = 0; i < self.targetEnemy.bulletsTargetingThis.length; i++) {
				potentialDamage += self.targetEnemy.bulletsTargetingThis[i].damage;
			}
			if (self.targetEnemy.health > potentialDamage) {
				var bulletX = self.x + Math.cos(gunContainer.rotation) * 40;
				var bulletY = self.y + Math.sin(gunContainer.rotation) * 40;
				var bullet = new Bullet(bulletX, bulletY, self.targetEnemy, self.damage, self.bulletSpeed);
				// Set bullet type based on tower type
				bullet.type = self.id;
				// For slow tower, pass level for scaling slow effect
				if (self.id === 'slow') {
					bullet.sourceTowerLevel = self.level;
				}
				// Customize bullet appearance based on tower type
				switch (self.id) {
					case 'rapid':
						bullet.children[0].tint = 0x00AAFF;
						bullet.children[0].width = 20;
						bullet.children[0].height = 20;
						break;
					case 'sniper':
						bullet.children[0].tint = 0xFF5500;
						bullet.children[0].width = 15;
						bullet.children[0].height = 15;
						break;
					case 'splash':
						bullet.children[0].tint = 0x33CC00;
						bullet.children[0].width = 40;
						bullet.children[0].height = 40;
						break;
					case 'slow':
						bullet.children[0].tint = 0x9900FF;
						bullet.children[0].width = 35;
						bullet.children[0].height = 35;
						break;
					case 'poison':
						bullet.children[0].tint = 0x00FFAA;
						bullet.children[0].width = 35;
						bullet.children[0].height = 35;
						break;
				}
				game.addChild(bullet);
				bullets.push(bullet);
				self.targetEnemy.bulletsTargetingThis.push(bullet);
				// --- Fire recoil effect for gunContainer ---
				// Stop any ongoing recoil tweens before starting a new one
				tween.stop(gunContainer, {
					x: true,
					y: true,
					scaleX: true,
					scaleY: true
				});
				// Always use the original resting position for recoil, never accumulate offset
				if (gunContainer._restX === undefined) {
					gunContainer._restX = 0;
				}
				if (gunContainer._restY === undefined) {
					gunContainer._restY = 0;
				}
				if (gunContainer._restScaleX === undefined) {
					gunContainer._restScaleX = 1;
				}
				if (gunContainer._restScaleY === undefined) {
					gunContainer._restScaleY = 1;
				}
				// Reset to resting position before animating (in case of interrupted tweens)
				gunContainer.x = gunContainer._restX;
				gunContainer.y = gunContainer._restY;
				gunContainer.scaleX = gunContainer._restScaleX;
				gunContainer.scaleY = gunContainer._restScaleY;
				// Calculate recoil offset (recoil back along the gun's rotation)
				var recoilDistance = 8;
				var recoilX = -Math.cos(gunContainer.rotation) * recoilDistance;
				var recoilY = -Math.sin(gunContainer.rotation) * recoilDistance;
				// Animate recoil back from the resting position
				tween(gunContainer, {
					x: gunContainer._restX + recoilX,
					y: gunContainer._restY + recoilY
				}, {
					duration: 60,
					easing: tween.cubicOut,
					onFinish: function onFinish() {
						// Animate return to original position/scale
						tween(gunContainer, {
							x: gunContainer._restX,
							y: gunContainer._restY
						}, {
							duration: 90,
							easing: tween.cubicIn
						});
					}
				});
			}
		}
	};
	self.placeOnGrid = function (gridX, gridY) {
		self.gridX = gridX;
		self.gridY = gridY;
		self.x = grid.x + gridX * CELL_SIZE + CELL_SIZE / 2;
		self.y = grid.y + gridY * CELL_SIZE + CELL_SIZE / 2;
		for (var i = 0; i < 2; i++) {
			for (var j = 0; j < 2; j++) {
				var cell = grid.getCell(gridX + i, gridY + j);
				if (cell) {
					cell.type = 1;
				}
			}
		}
		self.refreshCellsInRange();
	};
	return self;
});
var TowerPreview = Container.expand(function () {
	var self = Container.call(this);
	var towerRange = 3;
	var rangeInPixels = towerRange * CELL_SIZE;
	self.towerType = 'default';
	self.hasEnoughGold = true;
	var rangeIndicator = new Container();
	self.addChild(rangeIndicator);
	var rangeGraphics = rangeIndicator.attachAsset('rangeCircle', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	rangeGraphics.alpha = 0.3;
	var previewAsset = 'defense'; // Start with defense asset to match default
	var previewGraphics = self.attachAsset(previewAsset, {
		anchorX: 0.5,
		anchorY: 0.5
	});
	previewGraphics.width = CELL_SIZE * 2;
	previewGraphics.height = CELL_SIZE * 2;
	// Update preview asset when tower type changes
	self.updatePreviewAsset = function () {
		var needsSpecialAsset = true; // Always use special assets to match Tower class
		var specialAsset = 'defense'; // Default asset
		// Get active character for the tower type to determine correct asset
		var activeChar = getActiveCharacter(self.towerType);
		if (activeChar) {
			if (activeChar.name === 'Human Archer') {
				specialAsset = 'defense';
			} else if (activeChar.name === 'Elf Archer') {
				specialAsset = 'elf1';
			} else if (activeChar.name === 'Cannon Soldier') {
				specialAsset = 'cannon';
			} else if (activeChar.name === 'Catapult of Selena') {
				specialAsset = 'selena';
			} else if (activeChar.name === 'Lightning Mage') {
				specialAsset = 'lightingmage';
			} else if (activeChar.name === 'Frost Blaster') {
				specialAsset = 'frost';
			} else if (activeChar.name === 'Poison Archer') {
				specialAsset = 'poisonarcher';
			}
		} else {
			// Fallback based on tower type
			if (self.towerType === 'default') {
				specialAsset = 'defense';
			} else if (self.towerType === 'rapid') {
				specialAsset = 'cannon';
			} else if (self.towerType === 'sniper') {
				specialAsset = 'selena';
			} else if (self.towerType === 'splash') {
				specialAsset = 'lightingmage';
			} else if (self.towerType === 'slow') {
				specialAsset = 'frost';
			} else if (self.towerType === 'poison') {
				specialAsset = 'poisonarcher';
			}
		}
		// Always use the appropriate asset
		if (previewAsset !== specialAsset) {
			// Remove current preview and create new asset preview
			self.removeChild(previewGraphics);
			previewGraphics = self.attachAsset(specialAsset, {
				anchorX: 0.5,
				anchorY: 0.5
			});
			previewGraphics.width = CELL_SIZE * 2;
			previewGraphics.height = CELL_SIZE * 2;
			previewAsset = specialAsset;
		}
	};
	self.canPlace = false;
	self.gridX = 0;
	self.gridY = 0;
	self.blockedByEnemy = false;
	self.update = function () {
		var previousHasEnoughGold = self.hasEnoughGold;
		self.hasEnoughGold = gold >= getTowerCost(self.towerType);
		// Only update appearance if the affordability status has changed
		if (previousHasEnoughGold !== self.hasEnoughGold) {
			self.updateAppearance();
		}
	};
	self.updateAppearance = function () {
		// Update preview asset type if needed
		self.updatePreviewAsset();
		// Use Tower class to get the source of truth for range
		var tempTower = new Tower(self.towerType);
		var previewRange = tempTower.getRange();
		// Clean up tempTower to avoid memory leaks
		if (tempTower && tempTower.destroy) {
			tempTower.destroy();
		}
		// Set range indicator using unified range logic
		rangeGraphics.width = rangeGraphics.height = previewRange * 2;
		// Color assignment removed - characters use their natural asset colors
		// Apply custom hit area for special asset previews
		var needsCustomHitArea = false;
		if (self.towerType === 'default') {
			var activeChar = getActiveCharacter('default');
			if (activeChar && activeChar.name === 'Human Archer') {
				needsCustomHitArea = true;
			}
		} else if (self.towerType === 'rapid') {
			var activeChar = getActiveCharacter('rapid');
			if (activeChar && activeChar.name === 'Cannon Soldier') {
				needsCustomHitArea = true;
			}
		} else if (self.towerType === 'sniper') {
			var activeChar = getActiveCharacter('sniper');
			if (activeChar && activeChar.name === 'Catapult of Selena') {
				needsCustomHitArea = true;
			}
		} else if (self.towerType === 'splash') {
			var activeChar = getActiveCharacter('splash');
			if (activeChar && activeChar.name === 'Lightning Mage') {
				needsCustomHitArea = true;
			}
		} else if (self.towerType === 'slow') {
			var activeChar = getActiveCharacter('slow');
			if (activeChar && activeChar.name === 'Frost Blaster') {
				needsCustomHitArea = true;
			}
		} else if (self.towerType === 'poison') {
			var activeChar = getActiveCharacter('poison');
			if (activeChar && activeChar.name === 'Poison Archer') {
				needsCustomHitArea = true;
			}
		}
		if (needsCustomHitArea) {
			getNonTransparentBounds(previewGraphics, function (bounds) {
				previewGraphics.hitArea = {
					x: bounds.x - previewGraphics.width / 2,
					y: bounds.y - previewGraphics.height / 2,
					width: bounds.width,
					height: bounds.height
				};
			});
		}
		if (!self.canPlace || !self.hasEnoughGold) {
			previewGraphics.tint = 0xFF0000;
		}
	};
	self.updatePlacementStatus = function () {
		var validGridPlacement = true;
		if (self.gridY <= 4 || self.gridY + 1 >= grid.cells[0].length - 4) {
			validGridPlacement = false;
		} else {
			for (var i = 0; i < 2; i++) {
				for (var j = 0; j < 2; j++) {
					var cell = grid.getCell(self.gridX + i, self.gridY + j);
					if (!cell || cell.type !== 0) {
						validGridPlacement = false;
						break;
					}
				}
				if (!validGridPlacement) {
					break;
				}
			}
		}
		self.blockedByEnemy = false;
		if (validGridPlacement) {
			for (var i = 0; i < enemies.length; i++) {
				var enemy = enemies[i];
				if (enemy.currentCellY < 4) {
					continue;
				}
				// Only check non-flying enemies, flying enemies can pass over towers
				if (!enemy.isFlying) {
					if (enemy.cellX >= self.gridX && enemy.cellX < self.gridX + 2 && enemy.cellY >= self.gridY && enemy.cellY < self.gridY + 2) {
						self.blockedByEnemy = true;
						break;
					}
					if (enemy.currentTarget) {
						var targetX = enemy.currentTarget.x;
						var targetY = enemy.currentTarget.y;
						if (targetX >= self.gridX && targetX < self.gridX + 2 && targetY >= self.gridY && targetY < self.gridY + 2) {
							self.blockedByEnemy = true;
							break;
						}
					}
				}
			}
		}
		self.canPlace = validGridPlacement && !self.blockedByEnemy;
		self.hasEnoughGold = gold >= getTowerCost(self.towerType);
		self.updateAppearance();
	};
	self.checkPlacement = function () {
		self.updatePlacementStatus();
	};
	self.snapToGrid = function (x, y) {
		var gridPosX = x - grid.x;
		var gridPosY = y - grid.y;
		self.gridX = Math.floor(gridPosX / CELL_SIZE);
		self.gridY = Math.floor(gridPosY / CELL_SIZE);
		self.x = grid.x + self.gridX * CELL_SIZE + CELL_SIZE / 2;
		self.y = grid.y + self.gridY * CELL_SIZE + CELL_SIZE / 2;
		self.checkPlacement();
	};
	return self;
});
var UpgradeMenu = Container.expand(function (tower) {
	var self = Container.call(this);
	self.tower = tower;
	self.y = 2732 + 225;
	var menuBackground = self.attachAsset('notification', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	menuBackground.width = 2048;
	menuBackground.height = 500;
	menuBackground.tint = 0x444444;
	menuBackground.alpha = 0.9;
	var towerTypeText = new Text2((self.tower.id === 'default' ? 'Human Archer' : self.tower.id === 'sniper' ? 'Catapult of Selena' : self.tower.id.charAt(0).toUpperCase() + self.tower.id.slice(1)) + ' Tower', {
		size: 80,
		fill: 0xFFFFFF,
		weight: 800
	});
	towerTypeText.anchor.set(0, 0);
	towerTypeText.x = -840;
	towerTypeText.y = -160;
	self.addChild(towerTypeText);
	var statsText = new Text2('Level: ' + self.tower.level + '/' + self.tower.maxLevel + '\nDamage: ' + self.tower.damage + '\nFire Rate: ' + (60 / self.tower.fireRate).toFixed(1) + '/s', {
		size: 70,
		fill: 0xFFFFFF,
		weight: 400
	});
	statsText.anchor.set(0, 0.5);
	statsText.x = -840;
	statsText.y = 50;
	self.addChild(statsText);
	var buttonsContainer = new Container();
	buttonsContainer.x = 500;
	self.addChild(buttonsContainer);
	var upgradeButton = new Container();
	buttonsContainer.addChild(upgradeButton);
	var buttonBackground = upgradeButton.attachAsset('notification', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	buttonBackground.width = 500;
	buttonBackground.height = 150;
	var isMaxLevel = self.tower.level >= self.tower.maxLevel;
	// Exponential upgrade cost: base cost * (2 ^ (level-1)), scaled by tower base cost
	var baseUpgradeCost = getTowerCost(self.tower.id);
	var upgradeCost;
	if (isMaxLevel) {
		upgradeCost = 0;
	} else if (self.tower.level === self.tower.maxLevel - 1) {
		upgradeCost = Math.floor(baseUpgradeCost * Math.pow(2, self.tower.level - 1) * 3.5 / 2);
	} else {
		upgradeCost = Math.floor(baseUpgradeCost * Math.pow(2, self.tower.level - 1));
	}
	buttonBackground.tint = isMaxLevel ? 0x888888 : gold >= upgradeCost ? 0x00AA00 : 0x888888;
	var buttonText = new Text2(isMaxLevel ? 'Max Level' : 'Upgrade: ' + upgradeCost + ' gold', {
		size: 60,
		fill: 0xFFFFFF,
		weight: 800
	});
	buttonText.anchor.set(0.5, 0.5);
	upgradeButton.addChild(buttonText);
	var sellButton = new Container();
	buttonsContainer.addChild(sellButton);
	var sellButtonBackground = sellButton.attachAsset('notification', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	sellButtonBackground.width = 500;
	sellButtonBackground.height = 150;
	sellButtonBackground.tint = 0xCC0000;
	var totalInvestment = self.tower.getTotalValue ? self.tower.getTotalValue() : 0;
	var sellValue = getTowerSellValue(totalInvestment);
	var sellButtonText = new Text2('Sell: +' + sellValue + ' gold', {
		size: 60,
		fill: 0xFFFFFF,
		weight: 800
	});
	sellButtonText.anchor.set(0.5, 0.5);
	sellButton.addChild(sellButtonText);
	upgradeButton.y = -85;
	sellButton.y = 85;
	var closeButton = new Container();
	self.addChild(closeButton);
	var closeBackground = closeButton.attachAsset('notification', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	closeBackground.width = 90;
	closeBackground.height = 90;
	closeBackground.tint = 0xAA0000;
	var closeText = new Text2('X', {
		size: 68,
		fill: 0xFFFFFF,
		weight: 800
	});
	closeText.anchor.set(0.5, 0.5);
	closeButton.addChild(closeText);
	closeButton.x = menuBackground.width / 2 - 57;
	closeButton.y = -menuBackground.height / 2 + 57;
	upgradeButton.down = function (x, y, obj) {
		if (self.tower.level >= self.tower.maxLevel) {
			var notification = game.addChild(new Notification("Tower is already at max level!"));
			notification.x = 2048 / 2;
			notification.y = grid.height - 50;
			return;
		}
		if (self.tower.upgrade()) {
			// Exponential upgrade cost: base cost * (2 ^ (level-1)), scaled by tower base cost
			var baseUpgradeCost = getTowerCost(self.tower.id);
			if (self.tower.level >= self.tower.maxLevel) {
				upgradeCost = 0;
			} else if (self.tower.level === self.tower.maxLevel - 1) {
				upgradeCost = Math.floor(baseUpgradeCost * Math.pow(2, self.tower.level - 1) * 3.5 / 2);
			} else {
				upgradeCost = Math.floor(baseUpgradeCost * Math.pow(2, self.tower.level - 1));
			}
			statsText.setText('Level: ' + self.tower.level + '/' + self.tower.maxLevel + '\nDamage: ' + self.tower.damage + '\nFire Rate: ' + (60 / self.tower.fireRate).toFixed(1) + '/s');
			buttonText.setText('Upgrade: ' + upgradeCost + ' gold');
			var totalInvestment = self.tower.getTotalValue ? self.tower.getTotalValue() : 0;
			var sellValue = Math.floor(totalInvestment * 0.6);
			sellButtonText.setText('Sell: +' + sellValue + ' gold');
			if (self.tower.level >= self.tower.maxLevel) {
				buttonBackground.tint = 0x888888;
				buttonText.setText('Max Level');
			}
			var rangeCircle = null;
			for (var i = 0; i < game.children.length; i++) {
				if (game.children[i].isTowerRange && game.children[i].tower === self.tower) {
					rangeCircle = game.children[i];
					break;
				}
			}
			if (rangeCircle) {
				var rangeGraphics = rangeCircle.children[0];
				rangeGraphics.width = rangeGraphics.height = self.tower.getRange() * 2;
			} else {
				var newRangeIndicator = new Container();
				newRangeIndicator.isTowerRange = true;
				newRangeIndicator.tower = self.tower;
				game.addChildAt(newRangeIndicator, 0);
				newRangeIndicator.x = self.tower.x;
				newRangeIndicator.y = self.tower.y;
				var rangeGraphics = newRangeIndicator.attachAsset('rangeCircle', {
					anchorX: 0.5,
					anchorY: 0.5
				});
				rangeGraphics.width = rangeGraphics.height = self.tower.getRange() * 1;
				rangeGraphics.alpha = 0.3;
			}
			tween(self, {
				scaleX: 1.05,
				scaleY: 1.05
			}, {
				duration: 100,
				easing: tween.easeOut,
				onFinish: function onFinish() {
					tween(self, {
						scaleX: 1,
						scaleY: 1
					}, {
						duration: 100,
						easing: tween.easeIn
					});
				}
			});
		}
	};
	sellButton.down = function (x, y, obj) {
		var totalInvestment = self.tower.getTotalValue ? self.tower.getTotalValue() : 0;
		var sellValue = getTowerSellValue(totalInvestment);
		setGold(gold + sellValue);
		var notification = game.addChild(new Notification("Tower sold for " + sellValue + " gold!"));
		notification.x = 2048 / 2;
		notification.y = grid.height - 50;
		var gridX = self.tower.gridX;
		var gridY = self.tower.gridY;
		for (var i = 0; i < 2; i++) {
			for (var j = 0; j < 2; j++) {
				var cell = grid.getCell(gridX + i, gridY + j);
				if (cell) {
					cell.type = 0;
					var towerIndex = cell.towersInRange.indexOf(self.tower);
					if (towerIndex !== -1) {
						cell.towersInRange.splice(towerIndex, 1);
					}
				}
			}
		}
		if (selectedTower === self.tower) {
			selectedTower = null;
		}
		var towerIndex = towers.indexOf(self.tower);
		if (towerIndex !== -1) {
			towers.splice(towerIndex, 1);
		}
		towerLayer.removeChild(self.tower);
		grid.pathFind();
		grid.renderDebug();
		self.destroy();
		for (var i = 0; i < game.children.length; i++) {
			if (game.children[i].isTowerRange && game.children[i].tower === self.tower) {
				game.removeChild(game.children[i]);
				break;
			}
		}
	};
	closeButton.down = function (x, y, obj) {
		hideUpgradeMenu(self);
		selectedTower = null;
		grid.renderDebug();
	};
	self.update = function () {
		if (self.tower.level >= self.tower.maxLevel) {
			if (buttonText.text !== 'Max Level') {
				buttonText.setText('Max Level');
				buttonBackground.tint = 0x888888;
			}
			return;
		}
		// Exponential upgrade cost: base cost * (2 ^ (level-1)), scaled by tower base cost
		var baseUpgradeCost = getTowerCost(self.tower.id);
		var currentUpgradeCost;
		if (self.tower.level >= self.tower.maxLevel) {
			currentUpgradeCost = 0;
		} else if (self.tower.level === self.tower.maxLevel - 1) {
			currentUpgradeCost = Math.floor(baseUpgradeCost * Math.pow(2, self.tower.level - 1) * 3.5 / 2);
		} else {
			currentUpgradeCost = Math.floor(baseUpgradeCost * Math.pow(2, self.tower.level - 1));
		}
		var canAfford = gold >= currentUpgradeCost;
		buttonBackground.tint = canAfford ? 0x00AA00 : 0x888888;
		var newText = 'Upgrade: ' + currentUpgradeCost + ' gold';
		if (buttonText.text !== newText) {
			buttonText.setText(newText);
		}
	};
	return self;
});
var WaveIndicator = Container.expand(function () {
	var self = Container.call(this);
	self.gameStarted = false;
	self.waveMarkers = [];
	self.waveTypes = [];
	self.enemyCounts = [];
	self.indicatorWidth = 0;
	self.lastBossType = null; // Track the last boss type to avoid repeating
	var blockWidth = 400;
	var totalBlocksWidth = blockWidth * totalWaves;
	var startMarker = new Container();
	var startBlock = startMarker.attachAsset('notification', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	startBlock.width = blockWidth - 10;
	startBlock.height = 70 * 2;
	startBlock.tint = 0x00AA00;
	// Add shadow for start text
	var startTextShadow = new Text2("Start Game", {
		size: 50,
		fill: 0x000000,
		weight: 800
	});
	startTextShadow.anchor.set(0.5, 0.5);
	startTextShadow.x = 4;
	startTextShadow.y = 4;
	startMarker.addChild(startTextShadow);
	var startText = new Text2("Start Game", {
		size: 50,
		fill: 0xFFFFFF,
		weight: 800
	});
	startText.anchor.set(0.5, 0.5);
	startMarker.addChild(startText);
	startMarker.x = -self.indicatorWidth;
	self.addChild(startMarker);
	self.waveMarkers.push(startMarker);
	startMarker.down = function () {
		if (!self.gameStarted) {
			self.gameStarted = true;
			currentWave = 0;
			waveTimer = nextWaveTime;
			startBlock.tint = 0x00FF00;
			startText.setText("Started!");
			startTextShadow.setText("Started!");
			// Make sure shadow position remains correct after text change
			startTextShadow.x = 4;
			startTextShadow.y = 4;
			var notification = game.addChild(new Notification("Game started! Wave 1 incoming!"));
			notification.x = 2048 / 2;
			notification.y = grid.height - 150;
		}
	};
	for (var i = 0; i < totalWaves; i++) {
		var marker = new Container();
		var block = marker.attachAsset('notification', {
			anchorX: 0.5,
			anchorY: 0.5
		});
		block.width = blockWidth - 10;
		block.height = 70 * 2;
		// --- Begin new unified wave logic ---
		var waveType = "normal";
		var enemyType = "normal";
		var enemyCount = 10;
		var isBossWave = (i + 1) % 10 === 0;
		// Ensure all types appear in early waves
		if (i === 0) {
			block.tint = 0xAAAAAA;
			waveType = "Normal";
			enemyType = "normal";
			enemyCount = 10;
		} else if (i === 1) {
			block.tint = 0x00AAFF;
			waveType = "Fast";
			enemyType = "fast";
			enemyCount = 10;
		} else if (i === 2) {
			block.tint = 0xAA0000;
			waveType = "Immune";
			enemyType = "immune";
			enemyCount = 10;
		} else if (i === 3) {
			block.tint = 0xFFFF00;
			waveType = "Flying";
			enemyType = "flying";
			enemyCount = 10;
		} else if (i === 4) {
			block.tint = 0xFF00FF;
			waveType = "Swarm";
			enemyType = "swarm";
			enemyCount = 30;
		} else if (isBossWave) {
			// Boss waves: cycle through all boss types, last boss is always flying
			var bossTypes = ['normal', 'fast', 'immune', 'flying', 'swarm'];
			var bossTypeIndex = Math.floor((i + 1) / 10) - 1;
			if (i === totalWaves - 1) {
				// Last boss is always flying
				enemyType = 'Swarm';
				waveType = "Boss Swarm";
				block.tint = 0xFFFF00;
			} else {
				enemyType = bossTypes[bossTypeIndex % bossTypes.length];
				switch (enemyType) {
					case 'normal':
						block.tint = 0xAAAAAA;
						waveType = "Boss Normal";
						break;
					case 'fast':
						block.tint = 0x00AAFF;
						waveType = "Boss Fast";
						break;
					case 'immune':
						block.tint = 0xAA0000;
						waveType = "Boss Immune";
						break;
					case 'flying':
						block.tint = 0xFFFF00;
						waveType = "Boss Flying";
						break;
				}
			}
			enemyCount = 1;
			// Make the wave indicator for boss waves stand out
			// Set boss wave color to the color of the wave type
			switch (enemyType) {
				case 'normal':
					block.tint = 0xAAAAAA;
					break;
				case 'fast':
					block.tint = 0x00AAFF;
					break;
				case 'immune':
					block.tint = 0xAA0000;
					break;
				case 'flying':
					block.tint = 0xFFFF00;
					break;
				default:
					block.tint = 0xFF0000;
					break;
			}
		} else if ((i + 1) % 5 === 0) {
			// Every 5th non-boss wave is fast
			block.tint = 0x00AAFF;
			waveType = "Fast";
			enemyType = "fast";
			enemyCount = 10;
		} else if ((i + 1) % 4 === 0) {
			// Every 4th non-boss wave is immune
			block.tint = 0xAA0000;
			waveType = "Immune";
			enemyType = "immune";
			enemyCount = 10;
		} else if ((i + 1) % 7 === 0) {
			// Every 7th non-boss wave is flying
			block.tint = 0xFFFF00;
			waveType = "Flying";
			enemyType = "flying";
			enemyCount = 10;
		} else if ((i + 1) % 3 === 0) {
			// Every 3rd non-boss wave is swarm
			block.tint = 0xFF00FF;
			waveType = "Swarm";
			enemyType = "swarm";
			enemyCount = 30;
		} else {
			block.tint = 0xAAAAAA;
			waveType = "Normal";
			enemyType = "normal";
			enemyCount = 10;
		}
		// --- End new unified wave logic ---
		// Mark boss waves with a special visual indicator
		if (isBossWave && enemyType !== 'swarm') {
			// Add a crown or some indicator to the wave marker for boss waves
			var bossIndicator = marker.attachAsset('towerLevelIndicator', {
				anchorX: 0.5,
				anchorY: 0.5
			});
			bossIndicator.width = 30;
			bossIndicator.height = 30;
			bossIndicator.tint = 0xFFD700; // Gold color
			bossIndicator.y = -block.height / 2 - 15;
			// Change the wave type text to indicate boss
			waveType = "BOSS";
		}
		// Store the wave type and enemy count
		self.waveTypes[i] = enemyType;
		self.enemyCounts[i] = enemyCount;
		// Add shadow for wave type - 30% smaller than before
		var waveTypeShadow = new Text2(waveType, {
			size: 56,
			fill: 0x000000,
			weight: 800
		});
		waveTypeShadow.anchor.set(0.5, 0.5);
		waveTypeShadow.x = 4;
		waveTypeShadow.y = 4;
		marker.addChild(waveTypeShadow);
		// Add wave type text - 30% smaller than before
		var waveTypeText = new Text2(waveType, {
			size: 56,
			fill: 0xFFFFFF,
			weight: 800
		});
		waveTypeText.anchor.set(0.5, 0.5);
		waveTypeText.y = 0;
		marker.addChild(waveTypeText);
		// Add shadow for wave number - 20% larger than before
		var waveNumShadow = new Text2((i + 1).toString(), {
			size: 48,
			fill: 0x000000,
			weight: 800
		});
		waveNumShadow.anchor.set(1.0, 1.0);
		waveNumShadow.x = blockWidth / 2 - 16 + 5;
		waveNumShadow.y = block.height / 2 - 12 + 5;
		marker.addChild(waveNumShadow);
		// Main wave number text - 20% larger than before
		var waveNum = new Text2((i + 1).toString(), {
			size: 48,
			fill: 0xFFFFFF,
			weight: 800
		});
		waveNum.anchor.set(1.0, 1.0);
		waveNum.x = blockWidth / 2 - 16;
		waveNum.y = block.height / 2 - 12;
		marker.addChild(waveNum);
		marker.x = -self.indicatorWidth + (i + 1) * blockWidth;
		self.addChild(marker);
		self.waveMarkers.push(marker);
	}
	// Get wave type for a specific wave number
	self.getWaveType = function (waveNumber) {
		if (waveNumber < 1 || waveNumber > totalWaves) {
			return "normal";
		}
		// If this is a boss wave (waveNumber % 10 === 0), and the type is the same as lastBossType
		// then we should return a different boss type
		var waveType = self.waveTypes[waveNumber - 1];
		return waveType;
	};
	// Get enemy count for a specific wave number
	self.getEnemyCount = function (waveNumber) {
		if (waveNumber < 1 || waveNumber > totalWaves) {
			return 10;
		}
		return self.enemyCounts[waveNumber - 1];
	};
	// Get display name for a wave type
	self.getWaveTypeName = function (waveNumber) {
		var type = self.getWaveType(waveNumber);
		var typeName = type.charAt(0).toUpperCase() + type.slice(1);
		// Add boss prefix for boss waves (every 10th wave)
		if (waveNumber % 10 === 0 && waveNumber > 0 && type !== 'swarm') {
			typeName = "BOSS";
		}
		return typeName;
	};
	self.positionIndicator = new Container();
	var indicator = self.positionIndicator.attachAsset('towerLevelIndicator', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	indicator.width = blockWidth - 10;
	indicator.height = 16;
	indicator.tint = 0xffad0e;
	indicator.y = -65;
	var indicator2 = self.positionIndicator.attachAsset('towerLevelIndicator', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	indicator2.width = blockWidth - 10;
	indicator2.height = 16;
	indicator2.tint = 0xffad0e;
	indicator2.y = 65;
	var leftWall = self.positionIndicator.attachAsset('towerLevelIndicator', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	leftWall.width = 16;
	leftWall.height = 146;
	leftWall.tint = 0xffad0e;
	leftWall.x = -(blockWidth - 16) / 2;
	var rightWall = self.positionIndicator.attachAsset('towerLevelIndicator', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	rightWall.width = 16;
	rightWall.height = 146;
	rightWall.tint = 0xffad0e;
	rightWall.x = (blockWidth - 16) / 2;
	self.addChild(self.positionIndicator);
	self.update = function () {
		var progress = waveTimer / nextWaveTime;
		var moveAmount = (progress + currentWave) * blockWidth;
		for (var i = 0; i < self.waveMarkers.length; i++) {
			var marker = self.waveMarkers[i];
			marker.x = -moveAmount + i * blockWidth;
		}
		self.positionIndicator.x = 0;
		for (var i = 0; i < totalWaves + 1; i++) {
			var marker = self.waveMarkers[i];
			if (i === 0) {
				continue;
			}
			var block = marker.children[0];
			if (i - 1 < currentWave) {
				block.alpha = .5;
			}
		}
		self.handleWaveProgression = function () {
			if (!self.gameStarted) {
				return;
			}
			if (currentWave < totalWaves) {
				waveTimer++;
				if (waveTimer >= nextWaveTime) {
					waveTimer = 0;
					currentWave++;
					waveInProgress = true;
					waveSpawned = false;
					if (currentWave != 1) {
						var waveType = self.getWaveTypeName(currentWave);
						var enemyCount = self.getEnemyCount(currentWave);
						var notification = game.addChild(new Notification("Wave " + currentWave + " (" + waveType + " - " + enemyCount + " enemies) incoming!"));
						notification.x = 2048 / 2;
						notification.y = grid.height - 150;
					}
				}
			}
		};
		self.handleWaveProgression();
	};
	return self;
});

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

/**** 
* Game Code
****/ 
// Add backboard1 as background
var backgroundSprite = game.attachAsset('backboard1', {
	anchorX: 0,
	anchorY: 0
});
backgroundSprite.width = 2048;
backgroundSprite.height = 2732;
// Define complete kingdom data structure with enemies and towers for each kingdom
var kingdomData = [{
	name: 'Elf Kingdom',
	enemies: ['elf1', 'elf2', 'elf3', 'elf4', 'elf5'],
	towers: [{
		name: 'Human Archer',
		type: 'default',
		asset: 'defense'
	}, {
		name: 'Cannon Soldier',
		type: 'rapid',
		asset: 'cannon'
	}, {
		name: 'Catapult of Selena',
		type: 'sniper',
		asset: 'selena'
	}, {
		name: 'Lightning Mage',
		type: 'splash',
		asset: 'lightingmage'
	}, {
		name: 'Frost Blaster',
		type: 'slow',
		asset: 'frost'
	}, {
		name: 'Poison Archer',
		type: 'poison',
		asset: 'poisonarcher'
	}]
}, {
	name: 'Goblin Clans',
	enemies: ['goblin1', 'goblin2', 'goblin3', 'goblin4', 'goblin5'],
	towers: [{
		name: 'Elf Archer',
		type: 'default',
		asset: 'elf1'
	}, {
		name: 'Cannon Soldier',
		type: 'rapid',
		asset: 'cannon'
	}, {
		name: 'Catapult of Selena',
		type: 'sniper',
		asset: 'selena'
	}, {
		name: 'Lightning Mage',
		type: 'splash',
		asset: 'lightingmage'
	}, {
		name: 'Frost Blaster',
		type: 'slow',
		asset: 'frost'
	}, {
		name: 'Poison Archer',
		type: 'poison',
		asset: 'poisonarcher'
	}]
}, {
	name: 'Hawk Eye Tribe',
	enemies: ['hawk1', 'hawk2', 'hawk3', 'hawk4', 'hawk5'],
	towers: [{
		name: 'Goblin Grenadier',
		type: 'rapid',
		asset: 'goblin2'
	}, {
		name: 'Elf Archer',
		type: 'default',
		asset: 'elf1'
	}, {
		name: 'Catapult of Selena',
		type: 'sniper',
		asset: 'selena'
	}, {
		name: 'Lightning Mage',
		type: 'splash',
		asset: 'lightingmage'
	}, {
		name: 'Frost Blaster',
		type: 'slow',
		asset: 'frost'
	}, {
		name: 'Poison Archer',
		type: 'poison',
		asset: 'poisonarcher'
	}]
}, {
	name: 'Dragon Empire',
	enemies: ['dragon1', 'dragon2', 'dragon3', 'dragon4', 'dragon5'],
	towers: [{
		name: 'Beast Shaman',
		type: 'sniper',
		asset: 'hawk5'
	}, {
		name: 'Goblin Grenadier',
		type: 'rapid',
		asset: 'goblin2'
	}, {
		name: 'Elf Archer',
		type: 'default',
		asset: 'elf1'
	}, {
		name: 'Lightning Mage',
		type: 'splash',
		asset: 'lightingmage'
	}, {
		name: 'Frost Blaster',
		type: 'slow',
		asset: 'frost'
	}, {
		name: 'Poison Archer',
		type: 'poison',
		asset: 'poisonarcher'
	}]
}, {
	name: 'Shadow Tribe',
	enemies: ['shadow1', 'shadow2', 'shadow3', 'shadow4', 'shadow5'],
	towers: [{
		name: 'Flame Dragon',
		type: 'splash',
		asset: 'dragon5'
	}, {
		name: 'Beast Shaman',
		type: 'sniper',
		asset: 'hawk5'
	}, {
		name: 'Goblin Grenadier',
		type: 'rapid',
		asset: 'goblin2'
	}, {
		name: 'Elf Archer',
		type: 'default',
		asset: 'elf1'
	}, {
		name: 'Frost Blaster',
		type: 'slow',
		asset: 'frost'
	}, {
		name: 'Poison Archer',
		type: 'poison',
		asset: 'poisonarcher'
	}]
}, {
	name: 'Dark Bloom Kingdom',
	enemies: ['plant1', 'plant2', 'plant3', 'plant4', 'plant5'],
	towers: [{
		name: 'Dark Blaster',
		type: 'slow',
		asset: 'shadow5'
	}, {
		name: 'Flame Dragon',
		type: 'splash',
		asset: 'dragon5'
	}, {
		name: 'Beast Shaman',
		type: 'sniper',
		asset: 'hawk5'
	}, {
		name: 'Goblin Grenadier',
		type: 'rapid',
		asset: 'goblin2'
	}, {
		name: 'Elf Archer',
		type: 'default',
		asset: 'elf1'
	}, {
		name: 'Poison Archer',
		type: 'poison',
		asset: 'poisonarcher'
	}]
}, {
	name: 'Undead Kingdom',
	enemies: ['dead1', 'dead2', 'dead3', 'dead4', 'dead5'],
	towers: [{
		name: 'Venom Crawler',
		type: 'poison',
		asset: 'plant5'
	}, {
		name: 'Dark Blaster',
		type: 'slow',
		asset: 'shadow5'
	}, {
		name: 'Flame Dragon',
		type: 'splash',
		asset: 'dragon5'
	}, {
		name: 'Beast Shaman',
		type: 'sniper',
		asset: 'hawk5'
	}, {
		name: 'Goblin Grenadier',
		type: 'rapid',
		asset: 'goblin2'
	}, {
		name: 'Elf Archer',
		type: 'default',
		asset: 'elf1'
	}]
}];
// Create backwards compatibility kingdoms array from kingdomData
var kingdoms = kingdomData.map(function (kingdom, index) {
	return {
		name: kingdom.name,
		enemies: kingdom.enemies,
		reward: kingdom.towers.length > 1 ? {
			type: kingdom.towers[1].name,
			name: kingdom.towers[1].name,
			damage: 1.0,
			fireRate: 1.0,
			cost: index < 2 ? 5 : 10
		} : null
	};
});
var isHidingUpgradeMenu = false;
var gameState = storage.gameState || 'story';
var currentKingdom = storage.currentKingdom || 0;
// Initialize default characters - these cannot be stored directly due to storage limitations
var defaultCharacters = {
	'Human Archer': [{
		name: 'Human Archer',
		damage: 1.0,
		fireRate: 1.0,
		cost: 0
	}],
	'Cannon Soldier': [{
		name: 'Cannon Soldier',
		damage: 1.0,
		fireRate: 1.0,
		cost: 0
	}],
	'Catapult of Selena': [{
		name: 'Catapult of Selena',
		damage: 1.0,
		fireRate: 1.0,
		cost: 0
	}],
	'Lightning Mage': [{
		name: 'Lightning Mage',
		damage: 1.0,
		fireRate: 1.0,
		cost: 0
	}],
	'Frost Blaster': [{
		name: 'Frost Blaster',
		damage: 1.0,
		fireRate: 1.0,
		cost: 0
	}],
	'Poison Archer': [{
		name: 'Poison Archer',
		damage: 1.0,
		fireRate: 1.0,
		cost: 0
	}]
};
// Build unlockedCharacters from storage-friendly format
var unlockedCharacters = {};
for (var type in defaultCharacters) {
	unlockedCharacters[type] = defaultCharacters[type].slice(); // Copy default characters
}
// Load additional unlocked characters from storage using flattened structure
var unlockedCharacterNames = {
	'Human Archer': storage.unlockedCharacterNames_Human_Archer || [],
	'Cannon Soldier': storage.unlockedCharacterNames_Cannon_Soldier || [],
	'Catapult of Selena': storage.unlockedCharacterNames_Catapult_of_Selena || [],
	'Lightning Mage': storage.unlockedCharacterNames_Lightning_Mage || [],
	'Frost Blaster': storage.unlockedCharacterNames_Frost_Blaster || [],
	'Poison Archer': storage.unlockedCharacterNames_Poison_Archer || []
};
for (var type in unlockedCharacterNames) {
	if (unlockedCharacterNames[type] && unlockedCharacterNames[type].length > 0) {
		for (var i = 0; i < unlockedCharacterNames[type].length; i++) {
			var charName = unlockedCharacterNames[type][i];
			// Find character data from kingdoms
			for (var k = 0; k < kingdoms.length; k++) {
				if (kingdoms[k].reward && kingdoms[k].reward.name === charName) {
					var alreadyExists = false;
					for (var j = 0; j < unlockedCharacters[type].length; j++) {
						if (unlockedCharacters[type][j].name === charName) {
							alreadyExists = true;
							break;
						}
					}
					if (!alreadyExists) {
						unlockedCharacters[type].push(kingdoms[k].reward);
					}
					break;
				}
			}
		}
	}
}
var activeCharacters = storage.activeCharacters || {
	'Human Archer': 0,
	'Cannon Soldier': 0,
	'Catapult of Selena': 0,
	'Lightning Mage': 0,
	'Frost Blaster': 0,
	'Poison Archer': 0
};
function hideUpgradeMenu(menu) {
	if (isHidingUpgradeMenu) {
		return;
	}
	isHidingUpgradeMenu = true;
	tween(menu, {
		y: 2732 + 225
	}, {
		duration: 150,
		easing: tween.easeIn,
		onFinish: function onFinish() {
			menu.destroy();
			isHidingUpgradeMenu = false;
		}
	});
}
function getActiveCharacter(towerType) {
	// Map old tower type names to new display names
	var towerTypeMap = {
		'default': 'Human Archer',
		'rapid': 'Cannon Soldier',
		'sniper': 'Catapult of Selena',
		'splash': 'Lightning Mage',
		'slow': 'Frost Blaster',
		'poison': 'Poison Archer'
	};
	// Use mapped name if available, otherwise use the original towerType
	var mappedType = towerTypeMap[towerType] || towerType;
	// Check if the mapped type exists in unlockedCharacters
	if (!unlockedCharacters[mappedType]) {
		console.warn('Tower type not found:', mappedType);
		return null;
	}
	var index = activeCharacters[mappedType] || 0;
	return unlockedCharacters[mappedType][index];
}
function switchCharacter(towerType) {
	var available = unlockedCharacters[towerType];
	if (available && available.length > 1) {
		activeCharacters[towerType] = (activeCharacters[towerType] + 1) % available.length;
		storage.activeCharacters = activeCharacters;
	}
}
function unlockCharacter(reward) {
	if (reward && unlockedCharacters[reward.type] && !unlockedCharacters[reward.type].some(function (_char) {
		return _char.name === reward.name;
	})) {
		unlockedCharacters[reward.type].push(reward);
		// Store only character names in flattened storage structure with safe key names
		var storageKey = 'unlockedCharacterNames_' + reward.type.replace(/\s+/g, '_');
		var currentNames = storage[storageKey] || [];
		if (currentNames.indexOf(reward.name) === -1) {
			currentNames.push(reward.name);
			storage[storageKey] = currentNames;
		}
	}
}
var CELL_SIZE = 76;
var pathId = 1;
var maxScore = 0;
var enemies = [];
var towers = [];
var bullets = [];
var defenses = [];
var selectedTower = null;
var gold = 80;
var lives = 20;
var score = 0;
var currentWave = 0;
var totalWaves = 50;
var waveTimer = 0;
var waveInProgress = false;
var waveSpawned = false;
var nextWaveTime = 12000 / 2;
var sourceTower = null;
var enemiesToSpawn = 10; // Default number of enemies per wave
var goldText = new Text2('Gold: ' + gold, {
	size: 60,
	fill: 0xFFD700,
	weight: 800
});
goldText.anchor.set(0.5, 0.5);
var livesText = new Text2('Lives: ' + lives, {
	size: 60,
	fill: 0x00FF00,
	weight: 800
});
livesText.anchor.set(0.5, 0.5);
var scoreText = new Text2('Score: ' + score, {
	size: 60,
	fill: 0xFF0000,
	weight: 800
});
scoreText.anchor.set(0.5, 0.5);
var topMargin = 100;
var centerX = 2048 / 2;
var spacing = 400;
LK.gui.center.addChild(goldText);
LK.gui.center.addChild(livesText);
LK.gui.center.addChild(scoreText);
livesText.x = 0;
livesText.y = -2732 / 2 + topMargin;
goldText.x = -spacing;
goldText.y = -2732 / 2 + topMargin;
scoreText.x = spacing;
scoreText.y = -2732 / 2 + topMargin;
function updateUI() {
	goldText.setText('Gold: ' + gold);
	livesText.setText('Lives: ' + lives);
	scoreText.setText('Score: ' + score);
}
function setGold(value) {
	gold = value;
	updateUI();
}
var debugLayer = new Container();
var towerLayer = new Container();
// Create three separate layers for enemy hierarchy
var enemyLayerBottom = new Container(); // For normal enemies
var enemyLayerMiddle = new Container(); // For shadows
var enemyLayerTop = new Container(); // For flying enemies
var enemyLayer = new Container(); // Main container to hold all enemy layers
// Add layers in correct order (bottom first, then middle for shadows, then top)
enemyLayer.addChild(enemyLayerBottom);
enemyLayer.addChild(enemyLayerMiddle);
enemyLayer.addChild(enemyLayerTop);
var grid = new Grid(24, 29 + 6);
grid.x = 150;
grid.y = 200 - CELL_SIZE * 4;
grid.pathFind();
grid.renderDebug();
debugLayer.addChild(grid);
game.addChild(debugLayer);
game.addChild(towerLayer);
game.addChild(enemyLayer);
var offset = 0;
var towerPreview = new TowerPreview();
game.addChild(towerPreview);
towerPreview.visible = false;
var isDragging = false;
var dragCharacter = null;
// Helper function to get tight bounding box of non-transparent pixels
function getNonTransparentBounds(imageAsset, callback) {
	// For LK engine assets, we'll use predefined bounds for known assets
	// This is a simplified approach since we can't directly access canvas in LK
	var bounds = {
		x: 0,
		y: 0,
		width: imageAsset.width,
		height: imageAsset.height
	};
	// Predefined tight bounds for cannon asset (adjust these values based on your cannon.png)
	if (imageAsset._texture && imageAsset._texture.baseTexture && imageAsset._texture.baseTexture.imageUrl && imageAsset._texture.baseTexture.imageUrl.includes('cannon')) {
		// Assuming cannon visible area is roughly 60% of total image, centered
		var visibleWidth = imageAsset.width * 0.6;
		var visibleHeight = imageAsset.height * 0.6;
		bounds = {
			x: (imageAsset.width - visibleWidth) / 2,
			y: (imageAsset.height - visibleHeight) / 2,
			width: visibleWidth,
			height: visibleHeight
		};
	}
	callback(bounds);
}
function wouldBlockPath(gridX, gridY) {
	var cells = [];
	for (var i = 0; i < 2; i++) {
		for (var j = 0; j < 2; j++) {
			var cell = grid.getCell(gridX + i, gridY + j);
			if (cell) {
				cells.push({
					cell: cell,
					originalType: cell.type
				});
				cell.type = 1;
			}
		}
	}
	var blocked = grid.pathFind();
	for (var i = 0; i < cells.length; i++) {
		cells[i].cell.type = cells[i].originalType;
	}
	grid.pathFind();
	grid.renderDebug();
	return blocked;
}
function getTowerCost(towerType, character) {
	var baseCost = 5; // default cost
	switch (towerType) {
		case 'default':
		case 'Human Archer':
			baseCost = 5;
			break;
		case 'rapid':
		case 'Cannon Soldier':
			baseCost = 10;
			break;
		case 'sniper':
		case 'Catapult of Selena':
			baseCost = 15;
			break;
		case 'splash':
		case 'Lightning Mage':
			baseCost = 20;
			break;
		case 'slow':
		case 'Frost Blaster':
			baseCost = 30;
			break;
		case 'poison':
		case 'Poison Archer':
			baseCost = 40;
			break;
	}
	var activeChar = character || getActiveCharacter(towerType);
	return baseCost + (activeChar ? activeChar.cost || 0 : 0);
}
function getTowerSellValue(totalValue) {
	return waveIndicator && waveIndicator.gameStarted ? Math.floor(totalValue * 0.6) : totalValue;
}
function placeTower(gridX, gridY, towerType) {
	var towerCost = getTowerCost(towerType);
	if (gold >= towerCost) {
		var tower = new Tower(towerType || 'default');
		tower.placeOnGrid(gridX, gridY);
		towerLayer.addChild(tower);
		towers.push(tower);
		setGold(gold - towerCost);
		grid.pathFind();
		grid.renderDebug();
		return true;
	} else {
		var notification = game.addChild(new Notification("Not enough gold!"));
		notification.x = 2048 / 2;
		notification.y = grid.height - 50;
		return false;
	}
}
game.down = function (x, y, obj) {
	var upgradeMenuVisible = game.children.some(function (child) {
		return child instanceof UpgradeMenu;
	});
	if (upgradeMenuVisible) {
		return;
	}
	for (var i = 0; i < sourceTowers.length; i++) {
		var tower = sourceTowers[i];
		if (x >= tower.x - tower.width / 2 && x <= tower.x + tower.width / 2 && y >= tower.y - tower.height / 2 && y <= tower.y + tower.height / 2) {
			// Create a direct character preview instead of using TowerPreview
			if (dragCharacter) {
				dragCharacter.destroy();
			}
			dragCharacter = new Container();
			game.addChild(dragCharacter);
			// Map tower types to specific character assets based on active character
			var characterAssetName = 'defense'; // default
			var activeChar = getActiveCharacter(tower.towerType);
			if (activeChar) {
				if (activeChar.name === 'Human Archer') {
					characterAssetName = 'defense';
				} else if (activeChar.name === 'Elf Archer') {
					characterAssetName = 'elf1';
				} else if (activeChar.name === 'Cannon Soldier') {
					characterAssetName = 'cannon';
				} else if (activeChar.name === 'Catapult of Selena') {
					characterAssetName = 'selena';
				} else if (activeChar.name === 'Lightning Mage') {
					characterAssetName = 'lightingmage';
				} else if (activeChar.name === 'Frost Blaster') {
					characterAssetName = 'frost';
				} else if (activeChar.name === 'Poison Archer') {
					characterAssetName = 'poisonarcher';
				}
			} else {
				// Fallback based on tower type
				switch (tower.towerType) {
					case 'default':
						characterAssetName = 'defense';
						break;
					case 'rapid':
						characterAssetName = 'cannon';
						break;
					case 'sniper':
						characterAssetName = 'selena';
						break;
					case 'splash':
						characterAssetName = 'lightingmage';
						break;
					case 'slow':
						characterAssetName = 'frost';
						break;
					case 'poison':
						characterAssetName = 'poisonarcher';
						break;
				}
			}
			var characterGraphics = dragCharacter.attachAsset(characterAssetName, {
				anchorX: 0.5,
				anchorY: 0.5
			});
			characterGraphics.width = CELL_SIZE * 2;
			characterGraphics.height = CELL_SIZE * 2;
			// Store tower type for placement
			dragCharacter.towerType = tower.towerType;
			isDragging = true;
			// Position drag character directly at touch point without offset
			dragCharacter.x = x;
			dragCharacter.y = y;
			break;
		}
	}
};
game.move = function (x, y, obj) {
	if (isDragging && dragCharacter) {
		// Update drag character position directly to touch point
		dragCharacter.x = x;
		dragCharacter.y = y;
		// Calculate grid position for placement validation
		var gridPosX = x - grid.x;
		var gridPosY = y - grid.y;
		var gridX = Math.floor(gridPosX / CELL_SIZE);
		var gridY = Math.floor(gridPosY / CELL_SIZE);
		// Check placement validity
		var validGridPlacement = true;
		if (gridY <= 4 || gridY + 1 >= grid.cells[0].length - 4) {
			validGridPlacement = false;
		} else {
			for (var i = 0; i < 2; i++) {
				for (var j = 0; j < 2; j++) {
					var cell = grid.getCell(gridX + i, gridY + j);
					if (!cell || cell.type !== 0) {
						validGridPlacement = false;
						break;
					}
				}
				if (!validGridPlacement) {
					break;
				}
			}
		}
		// Check if blocked by enemy
		var blockedByEnemy = false;
		if (validGridPlacement) {
			for (var i = 0; i < enemies.length; i++) {
				var enemy = enemies[i];
				if (enemy.currentCellY < 4) {
					continue;
				}
				if (!enemy.isFlying) {
					if (enemy.cellX >= gridX && enemy.cellX < gridX + 2 && enemy.cellY >= gridY && enemy.cellY < gridY + 2) {
						blockedByEnemy = true;
						break;
					}
					if (enemy.currentTarget) {
						var targetX = enemy.currentTarget.x;
						var targetY = enemy.currentTarget.y;
						if (targetX >= gridX && targetX < gridX + 2 && targetY >= gridY && targetY < gridY + 2) {
							blockedByEnemy = true;
							break;
						}
					}
				}
			}
		}
		// Check if player can afford this tower and update visual feedback
		var canAfford = gold >= getTowerCost(dragCharacter.towerType);
		var canPlace = validGridPlacement && !blockedByEnemy;
		// Set tint based on affordability and placement validity
		if (!canAfford) {
			dragCharacter.children[0].tint = 0xFF0000; // Red if can't afford
		} else if (!canPlace) {
			dragCharacter.children[0].tint = 0xFF0000; // Red if can't place
		} else {
			dragCharacter.children[0].tint = 0xFFFFFF; // Normal color if can place
		}
		// Store placement info for use in up handler
		dragCharacter.gridX = gridX;
		dragCharacter.gridY = gridY;
		dragCharacter.canPlace = canPlace;
		dragCharacter.blockedByEnemy = blockedByEnemy;
	}
};
game.up = function (x, y, obj) {
	var clickedOnTower = false;
	for (var i = 0; i < towers.length; i++) {
		var tower = towers[i];
		var towerLeft = tower.x - tower.width / 2;
		var towerRight = tower.x + tower.width / 2;
		var towerTop = tower.y - tower.height / 2;
		var towerBottom = tower.y + tower.height / 2;
		if (x >= towerLeft && x <= towerRight && y >= towerTop && y <= towerBottom) {
			clickedOnTower = true;
			break;
		}
	}
	var upgradeMenus = game.children.filter(function (child) {
		return child instanceof UpgradeMenu;
	});
	if (upgradeMenus.length > 0 && !isDragging && !clickedOnTower) {
		var clickedOnMenu = false;
		for (var i = 0; i < upgradeMenus.length; i++) {
			var menu = upgradeMenus[i];
			var menuWidth = 2048;
			var menuHeight = 450;
			var menuLeft = menu.x - menuWidth / 2;
			var menuRight = menu.x + menuWidth / 2;
			var menuTop = menu.y - menuHeight / 2;
			var menuBottom = menu.y + menuHeight / 2;
			if (x >= menuLeft && x <= menuRight && y >= menuTop && y <= menuBottom) {
				clickedOnMenu = true;
				break;
			}
		}
		if (!clickedOnMenu) {
			for (var i = 0; i < upgradeMenus.length; i++) {
				var menu = upgradeMenus[i];
				hideUpgradeMenu(menu);
			}
			for (var i = game.children.length - 1; i >= 0; i--) {
				if (game.children[i].isTowerRange) {
					game.removeChild(game.children[i]);
				}
			}
			selectedTower = null;
			grid.renderDebug();
		}
	}
	if (isDragging && dragCharacter) {
		isDragging = false;
		if (dragCharacter.canPlace) {
			if (!wouldBlockPath(dragCharacter.gridX, dragCharacter.gridY)) {
				placeTower(dragCharacter.gridX, dragCharacter.gridY, dragCharacter.towerType);
			} else {
				var notification = game.addChild(new Notification("Tower would block the path!"));
				notification.x = 2048 / 2;
				notification.y = grid.height - 50;
			}
		} else if (dragCharacter.blockedByEnemy) {
			var notification = game.addChild(new Notification("Cannot build: Enemy in the way!"));
			notification.x = 2048 / 2;
			notification.y = grid.height - 50;
		} else {
			var notification = game.addChild(new Notification("Cannot build here!"));
			notification.x = 2048 / 2;
			notification.y = grid.height - 50;
		}
		// Clean up drag character
		dragCharacter.destroy();
		dragCharacter = null;
	}
};
var waveIndicator = new WaveIndicator();
waveIndicator.x = 2048 / 2;
waveIndicator.y = 2732 - 80;
game.addChild(waveIndicator);
var nextWaveButtonContainer = new Container();
var nextWaveButton = new NextWaveButton();
nextWaveButton.x = 2048 - 200;
nextWaveButton.y = 2732 - 100 + 20;
nextWaveButtonContainer.addChild(nextWaveButton);
game.addChild(nextWaveButtonContainer);
// Admin button for killing all enemies
var adminButton = new Container();
var adminButtonBg = adminButton.attachAsset('notification', {
	anchorX: 0.5,
	anchorY: 0.5
});
adminButtonBg.width = 250;
adminButtonBg.height = 80;
adminButtonBg.tint = 0xFF0000; // Red color for admin function
var adminButtonText = new Text2("Kill All", {
	size: 40,
	fill: 0xFFFFFF,
	weight: 800
});
adminButtonText.anchor.set(0.5, 0.5);
adminButton.addChild(adminButtonText);
adminButton.x = 150; // Position on left side
adminButton.y = 2732 - 100;
game.addChild(adminButton);
adminButton.down = function () {
	// Kill all enemies instantly
	for (var i = enemies.length - 1; i >= 0; i--) {
		var enemy = enemies[i];
		// Clean up bullets targeting this enemy
		for (var j = 0; j < enemy.bulletsTargetingThis.length; j++) {
			var bullet = enemy.bulletsTargetingThis[j];
			bullet.targetEnemy = null;
		}
		// Award gold for each enemy killed
		var goldEarned = enemy.isBoss ? Math.floor(50 + (enemy.waveNumber - 1) * 5) : Math.floor(1 + (enemy.waveNumber - 1) * 0.5);
		setGold(gold + goldEarned);
		// Award score
		var scoreValue = enemy.isBoss ? 100 : 5;
		score += scoreValue;
		// Clean up shadow if it's a flying enemy
		if (enemy.isFlying && enemy.shadow) {
			enemyLayerMiddle.removeChild(enemy.shadow);
			enemy.shadow = null;
		}
		// Remove enemy from the appropriate layer
		if (enemy.isFlying) {
			enemyLayerTop.removeChild(enemy);
		} else {
			enemyLayerBottom.removeChild(enemy);
		}
		enemies.splice(i, 1);
	}
	updateUI();
	// Show notification
	var notification = game.addChild(new Notification("All enemies eliminated!"));
	notification.x = 2048 / 2;
	notification.y = grid.height - 50;
	// Flash effect for dramatic impact
	tween(adminButtonBg, {
		scaleX: 1.2,
		scaleY: 1.2
	}, {
		duration: 100,
		easing: tween.easeOut,
		onFinish: function onFinish() {
			tween(adminButtonBg, {
				scaleX: 1,
				scaleY: 1
			}, {
				duration: 100,
				easing: tween.easeIn
			});
		}
	});
};
// Restart game button
var restartButton = new Container();
var restartButtonBg = restartButton.attachAsset('notification', {
	anchorX: 0.5,
	anchorY: 0.5
});
restartButtonBg.width = 250;
restartButtonBg.height = 80;
restartButtonBg.tint = 0x0088FF; // Blue color for restart
var restartButtonText = new Text2("Restart", {
	size: 40,
	fill: 0xFFFFFF,
	weight: 800
});
restartButtonText.anchor.set(0.5, 0.5);
restartButton.addChild(restartButtonText);
restartButton.x = 150; // Position on left side
restartButton.y = 2732 - 200; // Position above admin button
game.addChild(restartButton);
restartButton.down = function () {
	// Reset to kingdom 1
	currentKingdom = 0;
	storage.currentKingdom = 0;
	// Reset game state to story
	gameState = 'story';
	storage.gameState = 'story';
	// Reset wave progress
	currentWave = 0;
	waveTimer = 0;
	waveInProgress = false;
	waveSpawned = false;
	waveIndicator.gameStarted = false;
	waveIndicator.waveMarkers[0].children[0].tint = 0x00AA00;
	waveIndicator.waveMarkers[0].children[1].setText("Start Game");
	waveIndicator.waveMarkers[0].children[2].setText("Start Game");
	waveIndicator.waveMarkers[0].children[2].x = 4;
	waveIndicator.waveMarkers[0].children[2].y = 4;
	// Reset resources
	gold = 80;
	lives = 20;
	score = 0;
	updateUI();
	// Clear all towers
	for (var i = towers.length - 1; i >= 0; i--) {
		var tower = towers[i];
		// Clear tower from grid cells
		for (var x = 0; x < 2; x++) {
			for (var y = 0; y < 2; y++) {
				var cell = grid.getCell(tower.gridX + x, tower.gridY + y);
				if (cell) {
					cell.type = 0;
					var towerIndex = cell.towersInRange.indexOf(tower);
					if (towerIndex !== -1) {
						cell.towersInRange.splice(towerIndex, 1);
					}
				}
			}
		}
		towerLayer.removeChild(tower);
	}
	towers = [];
	selectedTower = null;
	// Clear upgrade menus and range indicators
	var upgradeMenus = game.children.filter(function (child) {
		return child instanceof UpgradeMenu;
	});
	for (var i = 0; i < upgradeMenus.length; i++) {
		upgradeMenus[i].destroy();
	}
	for (var i = game.children.length - 1; i >= 0; i--) {
		if (game.children[i].isTowerRange) {
			game.removeChild(game.children[i]);
		}
	}
	// Clear all bullets
	for (var i = bullets.length - 1; i >= 0; i--) {
		if (bullets[i].parent) {
			bullets[i].destroy();
		}
	}
	bullets = [];
	// Clear all enemies
	for (var i = enemies.length - 1; i >= 0; i--) {
		if (enemies[i].isFlying && enemies[i].shadow) {
			enemyLayerMiddle.removeChild(enemies[i].shadow);
		}
		if (enemies[i].isFlying) {
			enemyLayerTop.removeChild(enemies[i]);
		} else {
			enemyLayerBottom.removeChild(enemies[i]);
		}
	}
	enemies = [];
	// Recalculate paths
	grid.pathFind();
	grid.renderDebug();
	// Show notification
	var notification = game.addChild(new Notification("Game restarted! Starting from Kingdom 1."));
	notification.x = 2048 / 2;
	notification.y = grid.height - 50;
	// Flash effect for restart button
	tween(restartButtonBg, {
		scaleX: 1.2,
		scaleY: 1.2
	}, {
		duration: 100,
		easing: tween.easeOut,
		onFinish: function onFinish() {
			tween(restartButtonBg, {
				scaleX: 1,
				scaleY: 1
			}, {
				duration: 100,
				easing: tween.easeIn
			});
		}
	});
};
var towerTypes = ['default', 'rapid', 'sniper', 'splash', 'slow', 'poison'];
var sourceTowers = [];
var towerSpacing = 300; // Increase spacing for larger towers
var startX = 2048 / 2 - towerTypes.length * towerSpacing / 2 + towerSpacing / 2;
var towerY = 2732 - CELL_SIZE * 3 - 90;
for (var i = 0; i < towerTypes.length; i++) {
	var tower = new SourceTower(towerTypes[i]);
	tower.x = startX + i * towerSpacing;
	tower.y = towerY;
	towerLayer.addChild(tower);
	sourceTowers.push(tower);
}
sourceTower = null;
enemiesToSpawn = 10;
if (gameState === 'story') {
	var storyScreen = new StoryScreen();
	game.addChild(storyScreen);
}
game.update = function () {
	if (gameState === 'story') {
		if (!game.children.some(function (child) {
			return child instanceof StoryScreen;
		})) {
			var storyScreen = new StoryScreen();
			game.addChild(storyScreen);
		}
		return;
	} else if (gameState === 'inventory') {
		if (!game.children.some(function (child) {
			return child instanceof InventoryScreen;
		})) {
			var inventoryScreen = new InventoryScreen();
			game.addChild(inventoryScreen);
		}
		return;
	} else if (gameState !== 'playing') {
		return;
	}
	if (waveInProgress) {
		if (!waveSpawned) {
			waveSpawned = true;
			// Get wave type and enemy count from the wave indicator
			var waveType = waveIndicator.getWaveType(currentWave);
			var enemyCount = waveIndicator.getEnemyCount(currentWave);
			// Check if this is a boss wave
			var isBossWave = currentWave % 10 === 0 && currentWave > 0;
			if (isBossWave && waveType !== 'swarm') {
				// Boss waves have just 1 enemy regardless of what the wave indicator says
				enemyCount = 1;
				// Show boss announcement
				var notification = game.addChild(new Notification("⚠️ BOSS WAVE! ⚠️"));
				notification.x = 2048 / 2;
				notification.y = grid.height - 200;
			}
			// Spawn the appropriate number of enemies
			for (var i = 0; i < enemyCount; i++) {
				var enemy = new Enemy(waveType);
				// Add enemy to the appropriate layer based on type
				if (enemy.isFlying) {
					// Add flying enemy to the top layer
					enemyLayerTop.addChild(enemy);
					// If it's a flying enemy, add its shadow to the middle layer
					if (enemy.shadow) {
						enemyLayerMiddle.addChild(enemy.shadow);
					}
				} else {
					// Add normal/ground enemies to the bottom layer
					enemyLayerBottom.addChild(enemy);
				}
				// Scale difficulty with wave number but don't apply to boss
				// as bosses already have their health multiplier
				enemy.maxHealth = Math.round(enemy.maxHealth * Math.pow(1.12, currentWave));
				enemy.health = enemy.maxHealth;
				// Increment speed slightly with wave number
				enemy.speed = enemy.speed + currentWave * 0.002;
				// All enemy types now spawn in the middle 6 tiles at the top spacing
				var gridWidth = 24;
				var midPoint = Math.floor(gridWidth / 2); // 12
				// Find a column that isn't occupied by another enemy that's not yet in view
				var availableColumns = [];
				for (var col = midPoint - 3; col < midPoint + 3; col++) {
					var columnOccupied = false;
					// Check if any enemy is already in this column but not yet in view
					for (var e = 0; e < enemies.length; e++) {
						if (enemies[e].cellX === col && enemies[e].currentCellY < 4) {
							columnOccupied = true;
							break;
						}
					}
					if (!columnOccupied) {
						availableColumns.push(col);
					}
				}
				// If all columns are occupied, use original random method
				var spawnX;
				if (availableColumns.length > 0) {
					// Choose a random unoccupied column
					spawnX = availableColumns[Math.floor(Math.random() * availableColumns.length)];
				} else {
					// Fallback to random if all columns are occupied
					spawnX = midPoint - 3 + Math.floor(Math.random() * 6); // x from 9 to 14
				}
				var spawnY = -1 - Math.random() * 5; // Random distance above the grid for spreading
				enemy.cellX = spawnX;
				enemy.cellY = 5; // Position after entry
				enemy.currentCellX = spawnX;
				enemy.currentCellY = spawnY;
				enemy.waveNumber = currentWave;
				enemies.push(enemy);
			}
		}
		var currentWaveEnemiesRemaining = false;
		for (var i = 0; i < enemies.length; i++) {
			if (enemies[i].waveNumber === currentWave) {
				currentWaveEnemiesRemaining = true;
				break;
			}
		}
		if (waveSpawned && !currentWaveEnemiesRemaining) {
			waveInProgress = false;
			waveSpawned = false;
		}
	}
	for (var a = enemies.length - 1; a >= 0; a--) {
		var enemy = enemies[a];
		if (enemy.health <= 0) {
			for (var i = 0; i < enemy.bulletsTargetingThis.length; i++) {
				var bullet = enemy.bulletsTargetingThis[i];
				bullet.targetEnemy = null;
			}
			// Boss enemies give more gold and score
			var goldEarned = enemy.isBoss ? Math.floor(50 + (enemy.waveNumber - 1) * 5) : Math.floor(1 + (enemy.waveNumber - 1) * 0.5);
			var goldIndicator = new GoldIndicator(goldEarned, enemy.x, enemy.y);
			game.addChild(goldIndicator);
			setGold(gold + goldEarned);
			// Give more score for defeating a boss
			var scoreValue = enemy.isBoss ? 100 : 5;
			score += scoreValue;
			// Add a notification for boss defeat
			if (enemy.isBoss) {
				var notification = game.addChild(new Notification("Boss defeated! +" + goldEarned + " gold!"));
				notification.x = 2048 / 2;
				notification.y = grid.height - 150;
			}
			updateUI();
			// Clean up shadow if it's a flying enemy
			if (enemy.isFlying && enemy.shadow) {
				enemyLayerMiddle.removeChild(enemy.shadow);
				enemy.shadow = null;
			}
			// Remove enemy from the appropriate layer
			if (enemy.isFlying) {
				enemyLayerTop.removeChild(enemy);
			} else {
				enemyLayerBottom.removeChild(enemy);
			}
			enemies.splice(a, 1);
			continue;
		}
		if (grid.updateEnemy(enemy)) {
			// Clean up shadow if it's a flying enemy
			if (enemy.isFlying && enemy.shadow) {
				enemyLayerMiddle.removeChild(enemy.shadow);
				enemy.shadow = null;
			}
			// Remove enemy from the appropriate layer
			if (enemy.isFlying) {
				enemyLayerTop.removeChild(enemy);
			} else {
				enemyLayerBottom.removeChild(enemy);
			}
			enemies.splice(a, 1);
			lives = Math.max(0, lives - 1);
			updateUI();
			if (lives <= 0) {
				LK.showGameOver();
			}
		}
	}
	for (var i = bullets.length - 1; i >= 0; i--) {
		if (!bullets[i].parent) {
			if (bullets[i].targetEnemy) {
				var targetEnemy = bullets[i].targetEnemy;
				var bulletIndex = targetEnemy.bulletsTargetingThis.indexOf(bullets[i]);
				if (bulletIndex !== -1) {
					targetEnemy.bulletsTargetingThis.splice(bulletIndex, 1);
				}
			}
			bullets.splice(i, 1);
		}
	}
	if (towerPreview.visible) {
		towerPreview.checkPlacement();
	}
	if (currentWave >= totalWaves && enemies.length === 0 && !waveInProgress) {
		var kingdom = kingdoms[currentKingdom];
		if (kingdom && kingdom.reward) {
			unlockCharacter(kingdom.reward);
			var notification = game.addChild(new Notification("New warrior unlocked: " + kingdom.reward.name + "!"));
			notification.x = 2048 / 2;
			notification.y = grid.height - 100;
		}
		currentKingdom++;
		storage.currentKingdom = currentKingdom;
		if (currentKingdom >= 7) {
			// Reset to kingdom 1 after completing all 7 kingdoms
			currentKingdom = 0;
			storage.currentKingdom = currentKingdom;
			// Show you win screen, but game will restart from kingdom 1 when player hits play again
			LK.showYouWin();
			return;
		} else {
			gameState = 'inventory';
			storage.gameState = gameState;
		}
		currentWave = 0;
		waveTimer = 0;
		waveInProgress = false;
		waveSpawned = false;
		// Clear all placed towers when advancing to next kingdom
		for (var i = towers.length - 1; i >= 0; i--) {
			var tower = towers[i];
			// Clear tower from grid cells
			for (var x = 0; x < 2; x++) {
				for (var y = 0; y < 2; y++) {
					var cell = grid.getCell(tower.gridX + x, tower.gridY + y);
					if (cell) {
						cell.type = 0;
						// Remove tower from cell's towersInRange array
						var towerIndex = cell.towersInRange.indexOf(tower);
						if (towerIndex !== -1) {
							cell.towersInRange.splice(towerIndex, 1);
						}
					}
				}
			}
			// Remove tower from display
			towerLayer.removeChild(tower);
		}
		towers = [];
		// Clear any selected tower reference
		selectedTower = null;
		// Clear any upgrade menus
		var upgradeMenus = game.children.filter(function (child) {
			return child instanceof UpgradeMenu;
		});
		for (var i = 0; i < upgradeMenus.length; i++) {
			upgradeMenus[i].destroy();
		}
		// Clear any range indicators
		for (var i = game.children.length - 1; i >= 0; i--) {
			if (game.children[i].isTowerRange) {
				game.removeChild(game.children[i]);
			}
		}
		// Clear all bullets
		for (var i = bullets.length - 1; i >= 0; i--) {
			if (bullets[i].parent) {
				bullets[i].destroy();
			}
		}
		bullets = [];
		for (var i = enemies.length - 1; i >= 0; i--) {
			if (enemies[i].isFlying && enemies[i].shadow) {
				enemyLayerMiddle.removeChild(enemies[i].shadow);
			}
			if (enemies[i].isFlying) {
				enemyLayerTop.removeChild(enemies[i]);
			} else {
				enemyLayerBottom.removeChild(enemies[i]);
			}
		}
		enemies = [];
		// Recalculate paths after clearing towers
		grid.pathFind();
		grid.renderDebug();
	}
};

===================================================================
--- original.js
+++ change.js
@@ -2534,14 +2534,14 @@
 			enemyType = "swarm";
 			enemyCount = 30;
 		} else if (isBossWave) {
 			// Boss waves: cycle through all boss types, last boss is always flying
-			var bossTypes = ['normal', 'fast', 'immune', 'flying'];
+			var bossTypes = ['normal', 'fast', 'immune', 'flying', 'swarm'];
 			var bossTypeIndex = Math.floor((i + 1) / 10) - 1;
 			if (i === totalWaves - 1) {
 				// Last boss is always flying
-				enemyType = 'flying';
-				waveType = "Boss Flying";
+				enemyType = 'Swarm';
+				waveType = "Boss Swarm";
 				block.tint = 0xFFFF00;
 			} else {
 				enemyType = bossTypes[bossTypeIndex % bossTypes.length];
 				switch (enemyType) {