/**** 
* 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, bulletType) {
	var self = Container.call(this);
	self.targetEnemy = targetEnemy;
	self.damage = damage || 10;
	self.speed = speed || 5;
	self.type = bulletType || 'default';
	self.x = startX;
	self.y = startY;
	var bulletAssetId = 'bullet_' + self.type;
	var bulletGraphics = self.attachAsset(bulletAssetId, {
		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);
		// Special handling for Yura Yura (rapid) tower - use automatic hit system
		if (self.type === 'rapid') {
			// Initialize travel distance tracker if not set
			if (self.travelDistance === undefined) {
				self.travelDistance = 0;
				self.initialDistance = distance;
			}
			// Move bullet toward target
			var angle = Math.atan2(dy, dx);
			self.x += Math.cos(angle) * self.speed;
			self.y += Math.sin(angle) * self.speed;
			self.travelDistance += self.speed;
			// Automatic hit when bullet has traveled enough distance or is very close
			if (self.travelDistance >= self.initialDistance * 0.8 || distance < self.speed * 2) {
				// Check if Matthew enemy avoids damage (30% chance)
				var damageAvoided = false;
				if (self.targetEnemy.type === 'matthew' && self.targetEnemy.canAvoidDamage) {
					if (Math.random() < 0.3) {
						// 30% chance to avoid damage
						damageAvoided = true;
						// Create visual effect for avoided damage
						var avoidEffect = new EffectIndicator(self.targetEnemy.x, self.targetEnemy.y, 'avoid');
						game.addChild(avoidEffect);
					}
				}
				if (!damageAvoided) {
					// 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;
					}
				}
				self.destroy();
				return;
			}
			return;
		}
		// Special handling for Crush (splash) tower - use automatic hit system
		if (self.type === 'splash') {
			// Initialize travel distance tracker if not set
			if (self.travelDistance === undefined) {
				self.travelDistance = 0;
				self.initialDistance = distance;
			}
			// Move bullet toward target
			var angle = Math.atan2(dy, dx);
			self.x += Math.cos(angle) * self.speed;
			self.y += Math.sin(angle) * self.speed;
			self.travelDistance += self.speed;
			// Automatic hit when bullet has traveled enough distance or is very close
			if (self.travelDistance >= self.initialDistance * 0.8 || distance < self.speed * 2) {
				// Check if Matthew enemy avoids damage (30% chance)
				var damageAvoided = false;
				if (self.targetEnemy.type === 'matthew' && self.targetEnemy.canAvoidDamage) {
					if (Math.random() < 0.3) {
						// 30% chance to avoid damage
						damageAvoided = true;
						// Create visual effect for avoided damage
						var avoidEffect = new EffectIndicator(self.targetEnemy.x, self.targetEnemy.y, 'avoid');
						game.addChild(avoidEffect);
					}
				}
				if (!damageAvoided) {
					// 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;
					}
				}
				self.destroy();
				return;
			}
			return;
		}
		// Original hit detection for other tower types
		if (distance < self.speed) {
			// Check if Matthew enemy avoids damage (30% chance)
			var damageAvoided = false;
			if (self.targetEnemy.type === 'matthew' && self.targetEnemy.canAvoidDamage) {
				if (Math.random() < 0.3) {
					// 30% chance to avoid damage
					damageAvoided = true;
					// Create visual effect for avoided damage
					var avoidEffect = new EffectIndicator(self.targetEnemy.x, self.targetEnemy.y, 'avoid');
					game.addChild(avoidEffect);
				}
			}
			if (!damageAvoided) {
				// 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 = [];
	var numberLabel = new Text2('0', {
		size: 30,
		fill: 0xFFFFFF,
		weight: 800
	});
	numberLabel.anchor.set(.5, .5);
	self.addChild(numberLabel);
	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) {
		switch (data.type) {
			case 0:
			case 2:
				{
					if (data.pathId != pathId) {
						self.removeArrows();
						numberLabel.setText("-");
						cellGraphics.tint = 0x880000;
						return;
					}
					numberLabel.visible = true;
					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;
					}
					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;
					numberLabel.visible = false;
					break;
				}
			case 3:
				{
					self.removeArrows();
					cellGraphics.tint = 0x008800;
					numberLabel.visible = false;
					break;
				}
		}
		numberLabel.setText(Math.floor(data.score / 1000) / 10);
	};
});
var DefeatMenu = Container.expand(function () {
	var self = Container.call(this);
	// Background overlay
	var overlay = self.attachAsset('notification', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	overlay.width = 2048;
	overlay.height = 2732;
	overlay.tint = 0x000000;
	overlay.alpha = 0.8;
	// Main menu container
	var menuContainer = new Container();
	self.addChild(menuContainer);
	// Menu background
	var menuBg = menuContainer.attachAsset('notification', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	menuBg.width = 1800;
	menuBg.height = 2200;
	menuBg.tint = 0x444444;
	// Title
	var titleText = new Text2("GAME OVER", {
		size: 120,
		fill: 0xFF0000,
		weight: 800
	});
	titleText.anchor.set(0.5, 0.5);
	titleText.y = -900;
	menuContainer.addChild(titleText);
	// Current game stats
	var currentStatsText = new Text2("Wave Reached: " + currentWave + "\nScore: " + score + "\nGold Earned: " + gold, {
		size: 60,
		fill: 0xFFFFFF,
		weight: 600
	});
	currentStatsText.anchor.set(0.5, 0.5);
	currentStatsText.y = -700;
	menuContainer.addChild(currentStatsText);
	// Update local records
	var records = storage.records || {
		bestWave: 0,
		bestScore: 0,
		totalGames: 0
	};
	records.totalGames = (records.totalGames || 0) + 1;
	if (currentWave > (records.bestWave || 0)) {
		records.bestWave = currentWave;
	}
	if (score > (records.bestScore || 0)) {
		records.bestScore = score;
	}
	storage.records = records;
	// Local Records Button
	var recordsButton = new Container();
	var recordsBg = recordsButton.attachAsset('notification', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	recordsBg.width = 600;
	recordsBg.height = 150;
	recordsBg.tint = 0x0088FF;
	var recordsText = new Text2("LOCAL RECORDS", {
		size: 70,
		fill: 0xFFFFFF,
		weight: 800
	});
	recordsText.anchor.set(0.5, 0.5);
	recordsButton.addChild(recordsText);
	recordsButton.y = -400;
	menuContainer.addChild(recordsButton);
	// Return to Menu Button
	var menuButton = new Container();
	var menuBg = menuButton.attachAsset('notification', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	menuBg.width = 600;
	menuBg.height = 150;
	menuBg.tint = 0x00AA00;
	var menuText = new Text2("RETURN TO MENU", {
		size: 70,
		fill: 0xFFFFFF,
		weight: 800
	});
	menuText.anchor.set(0.5, 0.5);
	menuButton.addChild(menuText);
	menuButton.y = -200;
	menuContainer.addChild(menuButton);
	// Records panel (initially hidden)
	var recordsPanel = new Container();
	var recordsPanelBg = recordsPanel.attachAsset('notification', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	recordsPanelBg.width = 1600;
	recordsPanelBg.height = 1800;
	recordsPanelBg.tint = 0x333333;
	var recordsTitle = new Text2("LOCAL RECORDS", {
		size: 80,
		fill: 0xFFFFFF,
		weight: 800
	});
	recordsTitle.anchor.set(0.5, 0);
	recordsTitle.y = -800;
	recordsPanel.addChild(recordsTitle);
	var recordsContent = new Text2("Best Wave Reached: " + records.bestWave + "\nBest Score: " + records.bestScore + "\nTotal Games Played: " + records.totalGames + "\n\nCurrent Session:\nWave Reached: " + currentWave + "\nFinal Score: " + score + "\nGold Earned: " + gold, {
		size: 55,
		fill: 0xFFFFFF,
		weight: 400
	});
	recordsContent.anchor.set(0.5, 0);
	recordsContent.y = -600;
	recordsPanel.addChild(recordsContent);
	var recordsBackButton = new Container();
	var recordsBackBg = recordsBackButton.attachAsset('notification', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	recordsBackBg.width = 300;
	recordsBackBg.height = 100;
	recordsBackBg.tint = 0xAA0000;
	var recordsBackText = new Text2("BACK", {
		size: 60,
		fill: 0xFFFFFF,
		weight: 800
	});
	recordsBackText.anchor.set(0.5, 0.5);
	recordsBackButton.addChild(recordsBackText);
	recordsBackButton.y = 600;
	recordsPanel.addChild(recordsBackButton);
	recordsPanel.visible = false;
	self.addChild(recordsPanel);
	// Event handlers
	recordsButton.down = function () {
		menuContainer.visible = false;
		recordsPanel.visible = true;
	};
	menuButton.down = function () {
		self.destroy();
		// Reset all game variables to initial state
		gold = 80;
		lives = 20;
		score = 0;
		currentWave = 0;
		waveTimer = 0;
		waveInProgress = false;
		waveSpawned = false;
		selectedTower = null;
		isDragging = false;
		pathId = 1;
		maxScore = 0;
		// Clear all arrays
		enemies.length = 0;
		towers.length = 0;
		bullets.length = 0;
		defenses.length = 0;
		// Clear all containers
		towerLayer.removeChildren();
		enemyLayerBottom.removeChildren();
		enemyLayerMiddle.removeChildren();
		enemyLayerTop.removeChildren();
		// Remove range indicators and upgrade menus
		for (var i = game.children.length - 1; i >= 0; i--) {
			if (game.children[i].isTowerRange || game.children[i] instanceof UpgradeMenu) {
				game.removeChild(game.children[i]);
			}
		}
		// Hide tower preview
		towerPreview.visible = false;
		// Reset grid
		for (var i = 0; i < grid.cells.length; i++) {
			for (var j = 0; j < grid.cells[i].length; j++) {
				var cell = grid.cells[i][j];
				// Reset cell type to original state
				var cellType = i === 0 || i === grid.cells.length - 1 || j <= 4 || j >= grid.cells[i].length - 4 ? 1 : 0;
				if (i > 11 - 3 && i <= 11 + 3) {
					if (j === 0) {
						cellType = 2;
					} else if (j <= 4) {
						cellType = 0;
					} else if (j === grid.cells[i].length - 1) {
						cellType = 3;
					} else if (j >= grid.cells[i].length - 4) {
						cellType = 0;
					}
				}
				cell.type = cellType;
				cell.score = 0;
				cell.pathId = 0;
				cell.towersInRange = [];
			}
		}
		// Reset game started state and show start menu
		gameStarted = false;
		var newStartMenu = new StartMenu();
		game.addChild(newStartMenu);
		// Reset wave indicator
		waveIndicator.gameStarted = false;
		if (waveIndicator.waveMarkers.length > 0) {
			var startMarker = waveIndicator.waveMarkers[0];
			var startBlock = startMarker.children[0];
			var startText = startMarker.children[2];
			var startTextShadow = startMarker.children[1];
			startBlock.tint = 0x00AA00;
			startText.setText("Start Game");
			startTextShadow.setText("Start Game");
			startTextShadow.x = 4;
			startTextShadow.y = 4;
		}
		// Recreate source towers
		for (var i = 0; i < sourceTowers.length; i++) {
			towerLayer.addChild(sourceTowers[i]);
		}
		// Update pathfinding and UI
		grid.pathFind();
		grid.renderDebug();
		updateUI();
	};
	recordsBackButton.down = function () {
		recordsPanel.visible = false;
		menuContainer.visible = true;
	};
	// Position menu at center of screen
	menuContainer.x = 0;
	menuContainer.y = 0;
	self.x = 2048 / 2;
	self.y = 2732 / 2;
	return self;
});
// 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.5;
			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;
		case 'avoid':
			effectGraphics.tint = 0xFFFFFF;
			effectGraphics.width = effectGraphics.height = CELL_SIZE * 0.8;
			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;
	// Check if this is a boss wave
	// Check if this is a boss wave
	// Apply different stats based on enemy type
	switch (self.type) {
		case 'gyuvin':
			self.speed *= 2; // Twice as fast
			self.maxHealth = 100;
			break;
		case 'jiwoong':
			self.isImmune = true;
			self.maxHealth = 80;
			break;
		case 'ricky':
			self.isFlying = true;
			self.maxHealth = 80;
			break;
		case 'yujin':
			self.maxHealth = 50; // Weaker enemies
			break;
		case 'matthew':
			self.maxHealth = 100; // Same as Hanbin
			self.canAvoidDamage = true; // Special ability to randomly avoid damage
			break;
		case 'taerae':
			self.maxHealth = 100; // Same as Hanbin
			self.seeksTowers = true; // Special ability to seek and damage towers
			break;
		case 'hanbin':
		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;
	// Get appropriate asset for this enemy type
	var assetId = 'enemy';
	if (self.isBoss) {
		// All boss enemies use the Gunwook asset
		assetId = 'enemy_gunwook';
	} else if (self.type !== 'hanbin') {
		// Map new names to existing asset names
		var assetMap = {
			'gyuvin': 'fast',
			'ricky': 'ricky',
			'jiwoong': 'immune',
			'yujin': 'swarm',
			'matthew': 'matthew',
			'taerae': 'taerae'
		};
		var mappedType = assetMap[self.type] || self.type;
		assetId = 'enemy_' + mappedType;
	}
	var enemyGraphics = self.attachAsset(assetId, {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Scale up all enemies to double size
	enemyGraphics.scaleX = 2;
	enemyGraphics.scaleY = 2;
	// Scale up boss enemies even more (additional scaling)
	if (self.isBoss) {
		enemyGraphics.scaleX = 2.5;
		enemyGraphics.scaleY = 2.5;
	}
	// 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
		// Scale up all shadows to double size to match enemies
		shadowGraphics.scaleX = 2;
		shadowGraphics.scaleY = 2;
		// If this is a boss, scale up the shadow even more
		if (self.isBoss) {
			shadowGraphics.scaleX = 2.5;
			shadowGraphics.scaleY = 2.5;
		}
		// 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) {
				var angle = Math.atan2(oy, ox);
				if (enemyGraphics.targetRotation === undefined) {
					enemyGraphics.targetRotation = angle;
					enemyGraphics.rotation = angle;
				} else {
					if (Math.abs(angle - enemyGraphics.targetRotation) > 0.05) {
						tween.stop(enemyGraphics, {
							rotation: true
						});
						// Calculate the shortest angle to rotate
						var currentRotation = enemyGraphics.rotation;
						var angleDiff = angle - currentRotation;
						// Normalize angle difference to -PI to PI range for shortest path
						while (angleDiff > Math.PI) {
							angleDiff -= Math.PI * 2;
						}
						while (angleDiff < -Math.PI) {
							angleDiff += Math.PI * 2;
						}
						enemyGraphics.targetRotation = angle;
						tween(enemyGraphics, {
							rotation: currentRotation + angleDiff
						}, {
							duration: 250,
							easing: tween.easeOut
						});
					}
				}
			}
		}
		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;
		}
		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;
			// Rotate enemy graphic to face downward (PI/2 radians = 90 degrees)
			var angle = Math.PI / 2;
			if (enemy.children[0] && enemy.children[0].targetRotation === undefined) {
				enemy.children[0].targetRotation = angle;
				enemy.children[0].rotation = angle;
			} else if (enemy.children[0]) {
				if (Math.abs(angle - enemy.children[0].targetRotation) > 0.05) {
					tween.stop(enemy.children[0], {
						rotation: true
					});
					// Calculate the shortest angle to rotate
					var currentRotation = enemy.children[0].rotation;
					var angleDiff = angle - currentRotation;
					// Normalize angle difference to -PI to PI range for shortest path
					while (angleDiff > Math.PI) {
						angleDiff -= Math.PI * 2;
					}
					while (angleDiff < -Math.PI) {
						angleDiff += Math.PI * 2;
					}
					// Set target rotation and animate to it
					enemy.children[0].targetRotation = angle;
					tween(enemy.children[0], {
						rotation: currentRotation + angleDiff
					}, {
						duration: 250,
						easing: tween.easeOut
					});
				}
			}
			// 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;
		}
		// After reaching entry area, handle flying enemies differently
		if (enemy.isFlying) {
			// Flying enemies head straight to the closest goal
			if (!enemy.flyingTarget) {
				// Set flying target to the closest goal
				enemy.flyingTarget = self.goals[0];
				// Find closest goal if there are multiple
				if (self.goals.length > 1) {
					var closestDist = Infinity;
					for (var i = 0; i < self.goals.length; i++) {
						var goal = self.goals[i];
						var dx = goal.x - enemy.cellX;
						var dy = goal.y - enemy.cellY;
						var dist = dx * dx + dy * dy;
						if (dist < closestDist) {
							closestDist = dist;
							enemy.flyingTarget = goal;
						}
					}
				}
			}
			// Move directly toward the goal
			var ox = enemy.flyingTarget.x - enemy.currentCellX;
			var oy = enemy.flyingTarget.y - enemy.currentCellY;
			var dist = Math.sqrt(ox * ox + oy * oy);
			if (dist < enemy.speed) {
				// Reached the goal
				return true;
			}
			var angle = Math.atan2(oy, ox);
			// Rotate enemy graphic to match movement direction
			if (enemy.children[0] && enemy.children[0].targetRotation === undefined) {
				enemy.children[0].targetRotation = angle;
				enemy.children[0].rotation = angle;
			} else if (enemy.children[0]) {
				if (Math.abs(angle - enemy.children[0].targetRotation) > 0.05) {
					tween.stop(enemy.children[0], {
						rotation: true
					});
					// Calculate the shortest angle to rotate
					var currentRotation = enemy.children[0].rotation;
					var angleDiff = angle - currentRotation;
					// Normalize angle difference to -PI to PI range for shortest path
					while (angleDiff > Math.PI) {
						angleDiff -= Math.PI * 2;
					}
					while (angleDiff < -Math.PI) {
						angleDiff += Math.PI * 2;
					}
					// Set target rotation and animate to it
					enemy.children[0].targetRotation = angle;
					tween(enemy.children[0], {
						rotation: currentRotation + angleDiff
					}, {
						duration: 250,
						easing: tween.easeOut
					});
				}
			}
			// Update the cell position to track where the flying enemy is
			enemy.cellX = Math.round(enemy.currentCellX);
			enemy.cellY = Math.round(enemy.currentCellY);
			enemy.currentCellX += Math.cos(angle) * enemy.speed;
			enemy.currentCellY += Math.sin(angle) * enemy.speed;
			enemy.x = grid.x + enemy.currentCellX * CELL_SIZE;
			enemy.y = grid.y + enemy.currentCellY * CELL_SIZE;
			// Update shadow position if this is a flying enemy
			return false;
		}
		// Handle Taerae enemies - they seek towers instead of following paths
		if (enemy.type === 'taerae' && enemy.seeksTowers) {
			// Find the most powerful tower (highest level * damage)
			var targetTower = null;
			var highestPower = 0;
			for (var i = 0; i < towers.length; i++) {
				var tower = towers[i];
				var towerPower = tower.level * tower.damage;
				if (towerPower > highestPower) {
					highestPower = towerPower;
					targetTower = tower;
				}
			}
			if (targetTower) {
				// Move toward the most powerful tower
				var dx = targetTower.gridX - enemy.currentCellX;
				var dy = targetTower.gridY - enemy.currentCellY;
				var distance = Math.sqrt(dx * dx + dy * dy);
				// Check if close enough to stop behind the tower and break it
				if (distance < 2.5) {
					// Stop and completely destroy the tower
					var goldEarned = Math.floor(targetTower.getTotalValue() * 0.3);
					setGold(gold + goldEarned);
					var notification = game.addChild(new Notification("Tower destroyed by Taerae! +" + goldEarned + " gold recovered"));
					notification.x = 2048 / 2;
					notification.y = grid.height - 100;
					// Remove tower from grid
					for (var gi = 0; gi < 2; gi++) {
						for (var gj = 0; gj < 2; gj++) {
							var gridCell = grid.getCell(targetTower.gridX + gi, targetTower.gridY + gj);
							if (gridCell) {
								gridCell.type = 0;
							}
						}
					}
					// Remove tower from arrays and display
					var towerIndex = towers.indexOf(targetTower);
					if (towerIndex !== -1) {
						towers.splice(towerIndex, 1);
					}
					towerLayer.removeChild(targetTower);
					if (selectedTower === targetTower) {
						selectedTower = null;
					}
					// Taerae disappears after destroying tower
					enemy.health = 0;
					return false;
				}
				if (distance > enemy.speed) {
					var angle = Math.atan2(dy, dx);
					enemy.currentCellX += Math.cos(angle) * enemy.speed;
					enemy.currentCellY += Math.sin(angle) * enemy.speed;
				}
			}
			enemy.x = grid.x + enemy.currentCellX * CELL_SIZE;
			enemy.y = grid.y + enemy.currentCellY * CELL_SIZE;
			return false;
		}
		// Handle normal pathfinding 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);
			enemy.currentCellX += Math.cos(angle) * enemy.speed;
			enemy.currentCellY += Math.sin(angle) * enemy.speed;
		}
		enemy.x = grid.x + enemy.currentCellX * CELL_SIZE;
		enemy.y = grid.y + enemy.currentCellY * CELL_SIZE;
	};
});
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';
	// Increase size of base for easier touch
	var baseGraphics = self.attachAsset('tower', {
		anchorX: 0.5,
		anchorY: 0.5,
		scaleX: 1.3,
		scaleY: 1.3
	});
	switch (self.towerType) {
		case 'rapid':
			baseGraphics.tint = 0x00AAFF;
			break;
		case 'sniper':
			baseGraphics.tint = 0xFF5500;
			break;
		case 'splash':
			baseGraphics.tint = 0x33CC00;
			break;
		case 'slow':
			baseGraphics.tint = 0x9900FF;
			break;
		case 'poison':
			baseGraphics.tint = 0x00FFAA;
			break;
		default:
			baseGraphics.tint = 0xAAAAAA;
	}
	var towerCost = getTowerCost(self.towerType);
	// Get display name for tower type
	var displayName = getTowerDisplayName(self.towerType);
	// Add shadow for tower type label
	var typeLabelShadow = new Text2(displayName, {
		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 typeLabel = new Text2(displayName, {
		size: 50,
		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 StartMenu = Container.expand(function () {
	var self = Container.call(this);
	// Background overlay
	var overlay = self.attachAsset('notification', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	overlay.width = 2048;
	overlay.height = 2732;
	overlay.tint = 0x000000;
	overlay.alpha = 0.8;
	// Main menu container
	var menuContainer = new Container();
	self.addChild(menuContainer);
	// Menu background
	var menuBg = menuContainer.attachAsset('notification', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	menuBg.width = 1800;
	menuBg.height = 2200;
	menuBg.tint = 0x444444;
	// Title
	var titleText = new Text2("ZHANGHAO'S DURIAN DEFENSE", {
		size: 120,
		fill: 0xFFFFFF,
		weight: 800
	});
	titleText.anchor.set(0.5, 0.5);
	titleText.y = -900;
	menuContainer.addChild(titleText);
	// Game History Button
	var historyButton = new Container();
	var historyBg = historyButton.attachAsset('notification', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	historyBg.width = 600;
	historyBg.height = 150;
	historyBg.tint = 0x0088FF;
	var historyText = new Text2("HISTORY", {
		size: 70,
		fill: 0xFFFFFF,
		weight: 800
	});
	historyText.anchor.set(0.5, 0.5);
	historyButton.addChild(historyText);
	historyButton.y = -400;
	menuContainer.addChild(historyButton);
	// How to Play Button
	var howToPlayButton = new Container();
	var howToPlayBg = howToPlayButton.attachAsset('notification', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	howToPlayBg.width = 600;
	howToPlayBg.height = 150;
	howToPlayBg.tint = 0x00AA00;
	var howToPlayText = new Text2("HOW TO PLAY", {
		size: 70,
		fill: 0xFFFFFF,
		weight: 800
	});
	howToPlayText.anchor.set(0.5, 0.5);
	howToPlayButton.addChild(howToPlayText);
	howToPlayButton.y = -200;
	menuContainer.addChild(howToPlayButton);
	// Local Records Button
	var localRecordsButton = new Container();
	var localRecordsBg = localRecordsButton.attachAsset('notification', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	localRecordsBg.width = 600;
	localRecordsBg.height = 150;
	localRecordsBg.tint = 0x0088FF;
	var localRecordsText = new Text2("LOCAL RECORDS", {
		size: 70,
		fill: 0xFFFFFF,
		weight: 800
	});
	localRecordsText.anchor.set(0.5, 0.5);
	localRecordsButton.addChild(localRecordsText);
	localRecordsButton.y = 0;
	menuContainer.addChild(localRecordsButton);
	// Start Game Button
	var startButton = new Container();
	var startBg = startButton.attachAsset('notification', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	startBg.width = 600;
	startBg.height = 150;
	startBg.tint = 0xFF5500;
	var startText = new Text2("START GAME", {
		size: 70,
		fill: 0xFFFFFF,
		weight: 800
	});
	startText.anchor.set(0.5, 0.5);
	startButton.addChild(startText);
	startButton.y = 200;
	menuContainer.addChild(startButton);
	// History panel (initially hidden)
	var historyPanel = new Container();
	var historyPanelBg = historyPanel.attachAsset('notification', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	historyPanelBg.width = 1600;
	historyPanelBg.height = 1800;
	historyPanelBg.tint = 0x333333;
	var historyTitle = new Text2("ZhangHao's Durian Defense", {
		size: 80,
		fill: 0xFFFFFF,
		weight: 800
	});
	historyTitle.anchor.set(0.5, 0);
	historyTitle.y = -800;
	historyPanel.addChild(historyTitle);
	var historyContent = new Text2("Ever since Zhanghao brought home a single\ndurian, the dorm hasn't known peace.\nMembers of ZEROBASEONE have smelled the\nforbidden fruit… and they want more.\n\nFrom stealthy Sung Hanbin to chaotic Gyuvin,\neach member has one mission:\nSteal the secret stash of durians hidden\nin the kitchen.\n\nBut this time… Zhanghao is ready.", {
		size: 70,
		fill: 0xFFFFFF,
		weight: 400
	});
	historyContent.anchor.set(0.5, 0);
	historyContent.y = -600;
	historyPanel.addChild(historyContent);
	// Second page content (initially hidden)
	var historyContent2 = new Text2("Zhanghao's set up a powerful defense\nsystem powered by ZEROBASEONE's music!\n\nEach hit song activates a unique defense\ntower — from \"In Bloom\" to \"Sweat\",\nunleashing visual and sonic attacks to\nkeep the hungry members away.\n\nCan you help Zhanghao protect his\nprecious durians from the unstoppable\nchaos of his own group?\n\n⚔️ Defend the dorm.\nSave the durians.\nHonor the fruit.", {
		size: 70,
		fill: 0xFFFFFF,
		weight: 400
	});
	historyContent2.anchor.set(0.5, 0);
	historyContent2.y = -600;
	historyContent2.visible = false;
	historyPanel.addChild(historyContent2);
	// Next button (for first page)
	var historyNextButton = new Container();
	var historyNextBg = historyNextButton.attachAsset('notification', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	historyNextBg.width = 300;
	historyNextBg.height = 100;
	historyNextBg.tint = 0x0088FF;
	var historyNextText = new Text2("NEXT", {
		size: 60,
		fill: 0xFFFFFF,
		weight: 800
	});
	historyNextText.anchor.set(0.5, 0.5);
	historyNextButton.addChild(historyNextText);
	historyNextButton.y = 600;
	historyPanel.addChild(historyNextButton);
	// Back button (for second page, initially hidden)
	var historyBackFromPage2Button = new Container();
	var historyBackFromPage2Bg = historyBackFromPage2Button.attachAsset('notification', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	historyBackFromPage2Bg.width = 300;
	historyBackFromPage2Bg.height = 100;
	historyBackFromPage2Bg.tint = 0xAA0000;
	var historyBackFromPage2Text = new Text2("BACK", {
		size: 60,
		fill: 0xFFFFFF,
		weight: 800
	});
	historyBackFromPage2Text.anchor.set(0.5, 0.5);
	historyBackFromPage2Button.addChild(historyBackFromPage2Text);
	historyBackFromPage2Button.y = 600;
	historyBackFromPage2Button.visible = false;
	historyPanel.addChild(historyBackFromPage2Button);
	var historyBackButton = new Container();
	var historyBackBg = historyBackButton.attachAsset('notification', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	historyBackBg.width = 300;
	historyBackBg.height = 100;
	historyBackBg.tint = 0xAA0000;
	var historyBackText = new Text2("MENU", {
		size: 60,
		fill: 0xFFFFFF,
		weight: 800
	});
	historyBackText.anchor.set(0.5, 0.5);
	historyBackButton.addChild(historyBackText);
	historyBackButton.y = 500;
	historyPanel.addChild(historyBackButton);
	historyPanel.visible = false;
	self.addChild(historyPanel);
	// How to Play panel (initially hidden)
	var howToPanel = new Container();
	var howToPanelBg = howToPanel.attachAsset('notification', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	howToPanelBg.width = 1600;
	howToPanelBg.height = 1800;
	howToPanelBg.tint = 0x333333;
	var howToTitle = new Text2("HOW TO PLAY", {
		size: 80,
		fill: 0xFFFFFF,
		weight: 800
	});
	howToTitle.anchor.set(0.5, 0);
	howToTitle.y = -800;
	howToPanel.addChild(howToTitle);
	var howToContent = new Text2("The members of ZEROBASEONE are hungry…\nand dangerously obsessed with durians.\n\nZhanghao has hidden his precious stash\nin the kitchen, but the dorm has been\ncompromised.\n\nYour mission:\nStop the invading members before\nthey reach the kitchen and steal\nthe durians!", {
		size: 70,
		fill: 0xFFFFFF,
		weight: 400
	});
	howToContent.anchor.set(0.5, 0);
	howToContent.y = -600;
	howToPanel.addChild(howToContent);
	// Second page content (initially hidden)
	var howToContent2 = new Text2("TOWER TYPES:\n• In Bloom: Balanced damage and range\n• Yura Yura: Fast firing, more cost\n• Sweat: High damage, long range\n• Crush: Area damage to multiple enemies\n• Melting Point: Reduces enemy movement speed\n• Blue: Damage over time effect\n\nGAMEPLAY:\n1. Drag towers from bottom to place them\n2. Tap towers to upgrade or sell them\n3. Use 'Next Wave' button to speed up\n4. Survive all 50 waves to win!", {
		size: 70,
		fill: 0xFFFFFF,
		weight: 400
	});
	howToContent2.anchor.set(0.5, 0);
	howToContent2.y = -600;
	howToContent2.visible = false;
	howToPanel.addChild(howToContent2);
	// Third page content (initially hidden)
	var howToContent3 = new Text2("TIPS:\n• Block enemy paths strategically\n• Upgrade towers for better efficiency\n• Boss waves appear every 10 levels\n• Different enemy types require different\n  strategies\n• Flying enemies can't be slowed or\n  poisoned if they're immune\n• Save gold for upgrades - they're\n  much more powerful\n• Watch for swarm waves - many weak\n  enemies at once\n• Final upgrade levels give huge\n  power boosts", {
		size: 70,
		fill: 0xFFFFFF,
		weight: 400
	});
	howToContent3.anchor.set(0.5, 0);
	howToContent3.y = -600;
	howToContent3.visible = false;
	howToPanel.addChild(howToContent3);
	// Next button (for first page)
	var howToNextButton = new Container();
	var howToNextBg = howToNextButton.attachAsset('notification', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	howToNextBg.width = 300;
	howToNextBg.height = 100;
	howToNextBg.tint = 0x0088FF;
	var howToNextText = new Text2("NEXT", {
		size: 60,
		fill: 0xFFFFFF,
		weight: 800
	});
	howToNextText.anchor.set(0.5, 0.5);
	howToNextButton.addChild(howToNextText);
	howToNextButton.y = 600;
	howToPanel.addChild(howToNextButton);
	// Next button for page 2 (go to page 3)
	var howToNextButton2 = new Container();
	var howToNextBg2 = howToNextButton2.attachAsset('notification', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	howToNextBg2.width = 300;
	howToNextBg2.height = 100;
	howToNextBg2.tint = 0x0088FF;
	var howToNextText2 = new Text2("NEXT", {
		size: 60,
		fill: 0xFFFFFF,
		weight: 800
	});
	howToNextText2.anchor.set(0.5, 0.5);
	howToNextButton2.addChild(howToNextText2);
	howToNextButton2.y = 600;
	howToNextButton2.x = 200;
	howToNextButton2.visible = false;
	howToPanel.addChild(howToNextButton2);
	// Back button (for second page, initially hidden)
	var howToBackFromPage2Button = new Container();
	var howToBackFromPage2Bg = howToBackFromPage2Button.attachAsset('notification', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	howToBackFromPage2Bg.width = 300;
	howToBackFromPage2Bg.height = 100;
	howToBackFromPage2Bg.tint = 0xAA0000;
	var howToBackFromPage2Text = new Text2("BACK", {
		size: 60,
		fill: 0xFFFFFF,
		weight: 800
	});
	howToBackFromPage2Text.anchor.set(0.5, 0.5);
	howToBackFromPage2Button.addChild(howToBackFromPage2Text);
	howToBackFromPage2Button.y = 600;
	howToBackFromPage2Button.x = -200;
	howToBackFromPage2Button.visible = false;
	howToPanel.addChild(howToBackFromPage2Button);
	// Back button for page 3 (go to page 2)
	var howToBackFromPage3Button = new Container();
	var howToBackFromPage3Bg = howToBackFromPage3Button.attachAsset('notification', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	howToBackFromPage3Bg.width = 300;
	howToBackFromPage3Bg.height = 100;
	howToBackFromPage3Bg.tint = 0xAA0000;
	var howToBackFromPage3Text = new Text2("BACK", {
		size: 60,
		fill: 0xFFFFFF,
		weight: 800
	});
	howToBackFromPage3Text.anchor.set(0.5, 0.5);
	howToBackFromPage3Button.addChild(howToBackFromPage3Text);
	howToBackFromPage3Button.y = 600;
	howToBackFromPage3Button.visible = false;
	howToPanel.addChild(howToBackFromPage3Button);
	var howToBackButton = new Container();
	var howToBackBg = howToBackButton.attachAsset('notification', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	howToBackBg.width = 300;
	howToBackBg.height = 100;
	howToBackBg.tint = 0xAA0000;
	var howToBackText = new Text2("MENU", {
		size: 60,
		fill: 0xFFFFFF,
		weight: 800
	});
	howToBackText.anchor.set(0.5, 0.5);
	howToBackButton.addChild(howToBackText);
	howToBackButton.y = 500;
	howToPanel.addChild(howToBackButton);
	howToPanel.visible = false;
	self.addChild(howToPanel);
	// Local Records panel (initially hidden)
	var localRecordsPanel = new Container();
	var localRecordsPanelBg = localRecordsPanel.attachAsset('notification', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	localRecordsPanelBg.width = 1600;
	localRecordsPanelBg.height = 1800;
	localRecordsPanelBg.tint = 0x333333;
	var localRecordsTitle = new Text2("LOCAL RECORDS", {
		size: 80,
		fill: 0xFFFFFF,
		weight: 800
	});
	localRecordsTitle.anchor.set(0.5, 0);
	localRecordsTitle.y = -800;
	localRecordsPanel.addChild(localRecordsTitle);
	// Get records from storage
	var records = storage.records || {
		bestWave: 0,
		bestScore: 0,
		totalGames: 0
	};
	var localRecordsContent = new Text2("Best Wave Reached: " + records.bestWave + "\n\nBest Score: " + records.bestScore + "\n\nTotal Games Played: " + records.totalGames + "\n\n\nThese are your personal best records\nstored locally on this device.\n\nKeep playing to improve your scores\nand reach higher waves!", {
		size: 70,
		fill: 0xFFFFFF,
		weight: 400
	});
	localRecordsContent.anchor.set(0.5, 0);
	localRecordsContent.y = -600;
	localRecordsPanel.addChild(localRecordsContent);
	var localRecordsBackButton = new Container();
	var localRecordsBackBg = localRecordsBackButton.attachAsset('notification', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	localRecordsBackBg.width = 300;
	localRecordsBackBg.height = 100;
	localRecordsBackBg.tint = 0xAA0000;
	var localRecordsBackText = new Text2("BACK", {
		size: 60,
		fill: 0xFFFFFF,
		weight: 800
	});
	localRecordsBackText.anchor.set(0.5, 0.5);
	localRecordsBackButton.addChild(localRecordsBackText);
	localRecordsBackButton.y = 600;
	localRecordsPanel.addChild(localRecordsBackButton);
	localRecordsPanel.visible = false;
	self.addChild(localRecordsPanel);
	// Event handlers
	historyButton.down = function () {
		menuContainer.visible = false;
		historyPanel.visible = true;
	};
	howToPlayButton.down = function () {
		menuContainer.visible = false;
		howToPanel.visible = true;
	};
	localRecordsButton.down = function () {
		// Refresh records data when opening panel
		var currentRecords = storage.records || {
			bestWave: 0,
			bestScore: 0,
			totalGames: 0
		};
		localRecordsContent.setText("Best Wave Reached: " + currentRecords.bestWave + "\n\nBest Score: " + currentRecords.bestScore + "\n\nTotal Games Played: " + currentRecords.totalGames + "\n\n\nThese are your personal best records\nstored locally on this device.\n\nKeep playing to improve your scores\nand reach higher waves!");
		menuContainer.visible = false;
		localRecordsPanel.visible = true;
	};
	startButton.down = function () {
		self.destroy();
		gameStarted = true;
	};
	// Next button handler (go to page 2)
	historyNextButton.down = function () {
		historyContent.visible = false;
		historyContent2.visible = true;
		historyNextButton.visible = false;
		historyBackFromPage2Button.visible = true;
		historyBackButton.y = 500;
	};
	// Back from page 2 button handler (go to page 1)
	historyBackFromPage2Button.down = function () {
		historyContent.visible = true;
		historyContent2.visible = false;
		historyNextButton.visible = true;
		historyBackFromPage2Button.visible = false;
		historyBackButton.y = 500;
	};
	historyBackButton.down = function () {
		// Reset to first page when going back to main menu
		historyContent.visible = true;
		historyContent2.visible = false;
		historyNextButton.visible = true;
		historyBackFromPage2Button.visible = false;
		historyBackButton.y = 500;
		historyPanel.visible = false;
		menuContainer.visible = true;
	};
	// Next button handler (go to page 2)
	howToNextButton.down = function () {
		howToContent.visible = false;
		howToContent2.visible = true;
		howToNextButton.visible = false;
		howToBackFromPage2Button.visible = true;
		howToNextButton2.visible = true;
		howToBackButton.y = 500;
	};
	// Next button 2 handler (go to page 3)
	howToNextButton2.down = function () {
		howToContent2.visible = false;
		howToContent3.visible = true;
		howToNextButton2.visible = false;
		howToBackFromPage2Button.visible = false;
		howToBackFromPage3Button.visible = true;
		howToBackButton.y = 500;
	};
	// Back from page 2 button handler (go to page 1)
	howToBackFromPage2Button.down = function () {
		howToContent.visible = true;
		howToContent2.visible = false;
		howToNextButton.visible = true;
		howToBackFromPage2Button.visible = false;
		howToNextButton2.visible = false;
		howToBackButton.y = 500;
	};
	// Back from page 3 button handler (go to page 2)
	howToBackFromPage3Button.down = function () {
		howToContent2.visible = true;
		howToContent3.visible = false;
		howToNextButton2.visible = true;
		howToBackFromPage2Button.visible = true;
		howToBackFromPage3Button.visible = false;
		howToBackButton.y = 500;
	};
	howToBackButton.down = function () {
		// Reset to first page when going back to main menu
		howToContent.visible = true;
		howToContent2.visible = false;
		howToContent3.visible = false;
		howToNextButton.visible = true;
		howToBackFromPage2Button.visible = false;
		howToNextButton2.visible = false;
		howToBackFromPage3Button.visible = false;
		howToBackButton.y = 500;
		howToPanel.visible = false;
		menuContainer.visible = true;
	};
	localRecordsBackButton.down = function () {
		localRecordsPanel.visible = false;
		menuContainer.visible = true;
	};
	// Position menu at center of screen
	menuContainer.x = 0;
	menuContainer.y = 0;
	self.x = 2048 / 2;
	self.y = 2732 / 2;
	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;
	// 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 'sniper':
				// Sniper: 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 'splash':
				// Splash: base 2, +0.2 per level (max ~4 blocks at max level)
				return (2 + (self.level - 1) * 0.2) * CELL_SIZE;
			case 'rapid':
				// Rapid: base 2.5, +0.5 per level
				return (2.5 + (self.level - 1) * 0.5) * CELL_SIZE;
			case 'slow':
				// Slow: base 3.5, +0.5 per level
				return (3.5 + (self.level - 1) * 0.5) * CELL_SIZE;
			case 'poison':
				// Poison: base 3.2, +0.5 per level
				return (3.2 + (self.level - 1) * 0.5) * CELL_SIZE;
			default:
				// Default: 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 'rapid':
			self.fireRate = 30;
			self.damage = 10;
			self.range = 2.5 * CELL_SIZE;
			self.bulletSpeed = 7;
			break;
		case 'sniper':
			self.fireRate = 90;
			self.damage = 25;
			self.range = 5 * CELL_SIZE;
			self.bulletSpeed = 25;
			break;
		case 'splash':
			self.fireRate = 75;
			self.damage = 15;
			self.range = 2 * CELL_SIZE;
			self.bulletSpeed = 4;
			break;
		case 'slow':
			self.fireRate = 50;
			self.damage = 8;
			self.range = 3.5 * CELL_SIZE;
			self.bulletSpeed = 5;
			break;
		case 'poison':
			self.fireRate = 70;
			self.damage = 12;
			self.range = 3.2 * CELL_SIZE;
			self.bulletSpeed = 5;
			break;
	}
	var baseGraphics = self.attachAsset('tower', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	switch (self.id) {
		case 'rapid':
			baseGraphics.tint = 0x00AAFF;
			break;
		case 'sniper':
			baseGraphics.tint = 0xFF5500;
			break;
		case 'splash':
			baseGraphics.tint = 0x33CC00;
			break;
		case 'slow':
			baseGraphics.tint = 0x9900FF;
			break;
		case 'poison':
			baseGraphics.tint = 0x00FFAA;
			break;
		default:
			baseGraphics.tint = 0xAAAAAA;
	}
	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 defenseAssetId = 'defense_' + self.id;
	var gunGraphics = gunContainer.attachAsset(defenseAssetId, {
		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 {
				switch (self.id) {
					case 'rapid':
						towerLevelIndicator.tint = 0x00AAFF;
						break;
					case 'sniper':
						towerLevelIndicator.tint = 0xFF5500;
						break;
					case 'splash':
						towerLevelIndicator.tint = 0x33CC00;
						break;
					case 'slow':
						towerLevelIndicator.tint = 0x9900FF;
						break;
					case 'poison':
						towerLevelIndicator.tint = 0x00FFAA;
						break;
					default:
						towerLevelIndicator.tint = 0xAAAAAA;
				}
			}
		}
	};
	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() * 2;
		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, self.id);
				// For slow tower, pass level for scaling slow effect
				if (self.id === 'slow') {
					bullet.sourceTowerLevel = self.level;
				}
				// Apply tower-specific bullet tinting
				switch (self.id) {
					case 'rapid':
						bullet.children[0].tint = 0xff8da1;
						break;
					case 'sniper':
						bullet.children[0].tint = 0xFF5500;
						break;
					case 'splash':
						bullet.children[0].tint = 0x33CC00;
						break;
					case 'slow':
						bullet.children[0].tint = 0x9900FF;
						break;
					case 'poison':
						bullet.children[0].tint = 0x00FFAA;
						break;
					case 'default':
						bullet.children[0].tint = 0xAAAAAA;
						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 previewGraphics = self.attachAsset('towerpreview', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	previewGraphics.width = CELL_SIZE * 2;
	previewGraphics.height = CELL_SIZE * 2;
	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 () {
		// 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;
		switch (self.towerType) {
			case 'rapid':
				previewGraphics.tint = 0x00AAFF;
				break;
			case 'sniper':
				previewGraphics.tint = 0xFF5500;
				break;
			case 'splash':
				previewGraphics.tint = 0x33CC00;
				break;
			case 'slow':
				previewGraphics.tint = 0x9900FF;
				break;
			case 'poison':
				previewGraphics.tint = 0x00FFAA;
				break;
			default:
				previewGraphics.tint = 0xAAAAAA;
		}
		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(getTowerDisplayName(self.tower.id) + ' 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() * 2;
				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 && 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 = "hanbin";
		var enemyType = "hanbin";
		var enemyCount = 10;
		var isBossWave = (i + 1) % 10 === 0;
		// Ensure all types appear in early waves
		if (i === 0) {
			block.tint = 0xAAAAAA;
			waveType = "Hanbin";
			enemyType = "hanbin";
			enemyCount = 10;
		} else if (i === 1) {
			block.tint = 0x00AAFF;
			waveType = "Gyuvin";
			enemyType = "gyuvin";
			enemyCount = 10;
		} else if (i === 2) {
			block.tint = 0xAA0000;
			waveType = "Jiwoong";
			enemyType = "jiwoong";
			enemyCount = 10;
		} else if (i === 3) {
			block.tint = 0xFFFF00;
			waveType = "Ricky";
			enemyType = "ricky";
			enemyCount = 10;
		} else if (i === 4) {
			block.tint = 0xFF00FF;
			waveType = "Yujin";
			enemyType = "yujin";
			enemyCount = 30;
		} else if (i === 5) {
			block.tint = 0x888800;
			waveType = "Matthew";
			enemyType = "matthew";
			enemyCount = 10;
		} else if (i + 1 === 13 || i + 1 > 13 && (i + 1 - 13) % 4 === 0 && (i + 1) % 10 !== 0 && i + 1 !== 49) {
			// Taerae appears on level 13 and every 4 levels after, except boss levels and level 49
			block.tint = 0xFF8C00;
			waveType = "Taerae";
			enemyType = "taerae";
			enemyCount = 8;
		} else if (i + 1 === 49) {
			// Matthew level at 49
			block.tint = 0x888800;
			waveType = "Matthew";
			enemyType = "matthew";
			enemyCount = 10;
		} else if (i + 1 === 22 || i + 1 === 43) {
			// Gyuvin levels at 22 and 43
			block.tint = 0x00AAFF;
			waveType = "Gyuvin";
			enemyType = "gyuvin";
			enemyCount = 10;
		} else if (i + 1 === 23 || i + 1 === 47) {
			// Matthew levels at 23 and 47
			block.tint = 0x888800;
			waveType = "Matthew";
			enemyType = "matthew";
			enemyCount = 10;
		} else if (isBossWave) {
			// Boss waves: cycle through all boss types as underlying mechanics, but display as Gunwook
			var bossTypes = ['hanbin', 'gyuvin', 'jiwoong', 'ricky'];
			var bossTypeIndex = Math.floor((i + 1) / 10) - 1;
			if (i === totalWaves - 1) {
				// Last boss is always ricky mechanically
				enemyType = 'ricky';
			} else {
				enemyType = bossTypes[bossTypeIndex % bossTypes.length];
			}
			// All boss waves display as "Gunwook" regardless of underlying type
			waveType = "Gunwook";
			block.tint = 0xFF6600; // Orange color for Gunwook boss
			enemyCount = 1;
		} else if ((i + 1) % 5 === 0) {
			// Every 5th non-boss wave is gyuvin
			block.tint = 0x00AAFF;
			waveType = "Gyuvin";
			enemyType = "gyuvin";
			enemyCount = 10;
		} else if ((i + 1) % 4 === 0 && i + 1 !== 32) {
			// Every 4th non-boss wave is jiwoong, except level 32
			block.tint = 0xAA0000;
			waveType = "Jiwoong";
			enemyType = "jiwoong";
			enemyCount = 10;
		} else if (i + 1 === 32) {
			// Matthew level at 32
			block.tint = 0x888800;
			waveType = "Matthew";
			enemyType = "matthew";
			enemyCount = 10;
		} else if ((i + 1) % 7 === 0) {
			// Every 7th non-boss wave is ricky
			block.tint = 0xFFFF00;
			waveType = "Ricky";
			enemyType = "ricky";
			enemyCount = 10;
		} else if ((i + 1) % 3 === 0) {
			// Every 3rd non-boss wave is yujin
			block.tint = 0xFF00FF;
			waveType = "Yujin";
			enemyType = "yujin";
			enemyCount = 30;
		} else {
			block.tint = 0xAAAAAA;
			waveType = "Hanbin";
			enemyType = "hanbin";
			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 = "Gunwook";
		}
		// 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 !== 'yujin') {
			typeName = "Gunwook";
		}
		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 || !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
****/ 
var isHidingUpgradeMenu = false;
var gameStarted = false;
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;
		}
	});
}
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('DURIANS: ' + 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);
// Create reset button
var resetButton = new Container();
var resetButtonBg = resetButton.attachAsset('notification', {
	anchorX: 0.5,
	anchorY: 0.5
});
resetButtonBg.width = 120;
resetButtonBg.height = 80;
resetButtonBg.tint = 0xFF4444;
var resetText = new Text2('RESET', {
	size: 45,
	fill: 0xFFFFFF,
	weight: 800
});
resetText.anchor.set(0.5, 0.5);
resetButton.addChild(resetText);
resetButton.down = function () {
	// Reset all game variables to initial state
	gold = 80;
	lives = 20;
	score = 0;
	currentWave = 0;
	waveTimer = 0;
	waveInProgress = false;
	waveSpawned = false;
	selectedTower = null;
	isDragging = false;
	pathId = 1;
	maxScore = 0;
	// Clear all arrays
	enemies.length = 0;
	towers.length = 0;
	bullets.length = 0;
	defenses.length = 0;
	// Clear all containers
	towerLayer.removeChildren();
	enemyLayerBottom.removeChildren();
	enemyLayerMiddle.removeChildren();
	enemyLayerTop.removeChildren();
	// Remove range indicators and upgrade menus
	for (var i = game.children.length - 1; i >= 0; i--) {
		if (game.children[i].isTowerRange || game.children[i] instanceof UpgradeMenu) {
			game.removeChild(game.children[i]);
		}
	}
	// Hide tower preview
	towerPreview.visible = false;
	// Reset grid
	for (var i = 0; i < grid.cells.length; i++) {
		for (var j = 0; j < grid.cells[i].length; j++) {
			var cell = grid.cells[i][j];
			// Reset cell type to original state
			var cellType = i === 0 || i === grid.cells.length - 1 || j <= 4 || j >= grid.cells[i].length - 4 ? 1 : 0;
			if (i > 11 - 3 && i <= 11 + 3) {
				if (j === 0) {
					cellType = 2;
				} else if (j <= 4) {
					cellType = 0;
				} else if (j === grid.cells[i].length - 1) {
					cellType = 3;
				} else if (j >= grid.cells[i].length - 4) {
					cellType = 0;
				}
			}
			cell.type = cellType;
			cell.score = 0;
			cell.pathId = 0;
			cell.towersInRange = [];
		}
	}
	// Reset game started state and show start menu
	gameStarted = false;
	var newStartMenu = new StartMenu();
	game.addChild(newStartMenu);
	// Reset wave indicator
	waveIndicator.gameStarted = false;
	if (waveIndicator.waveMarkers.length > 0) {
		var startMarker = waveIndicator.waveMarkers[0];
		var startBlock = startMarker.children[0];
		var startText = startMarker.children[2];
		var startTextShadow = startMarker.children[1];
		startBlock.tint = 0x00AA00;
		startText.setText("Start Game");
		startTextShadow.setText("Start Game");
		startTextShadow.x = 4;
		startTextShadow.y = 4;
	}
	// Recreate source towers
	for (var i = 0; i < sourceTowers.length; i++) {
		towerLayer.addChild(sourceTowers[i]);
	}
	// Update pathfinding and UI
	grid.pathFind();
	grid.renderDebug();
	updateUI();
	var notification = game.addChild(new Notification("Game Reset!"));
	notification.x = 2048 / 2;
	notification.y = grid.height - 50;
};
var topMargin = 50;
var centerX = 2048 / 2;
var spacing = 400;
LK.gui.top.addChild(goldText);
LK.gui.top.addChild(livesText);
LK.gui.top.addChild(scoreText);
LK.gui.topRight.addChild(resetButton);
livesText.x = 0;
livesText.y = topMargin;
goldText.x = -spacing;
goldText.y = topMargin;
scoreText.x = spacing;
scoreText.y = topMargin;
resetButton.x = -80;
resetButton.y = 50;
function updateUI() {
	goldText.setText('Gold: ' + gold);
	livesText.setText('DURIANS: ' + 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;
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 getTowerDisplayName(towerType) {
	switch (towerType) {
		case 'default':
			return 'In Bloom';
		case 'rapid':
			return 'Yura Yura';
		case 'sniper':
			return 'Sweat';
		case 'splash':
			return 'Crush';
		case 'slow':
			return 'Melting Point';
		case 'poison':
			return 'Blue';
		default:
			return towerType.charAt(0).toUpperCase() + towerType.slice(1);
	}
}
function getTowerCost(towerType) {
	var cost = 5;
	switch (towerType) {
		case 'rapid':
			cost = 15;
			break;
		case 'sniper':
			cost = 25;
			break;
		case 'splash':
			cost = 35;
			break;
		case 'slow':
			cost = 45;
			break;
		case 'poison':
			cost = 55;
			break;
	}
	return cost;
}
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();
		// Play tower placement sound based on tower type
		switch (towerType) {
			case 'default':
				LK.getSound('InBloom_tower').play();
				break;
			case 'rapid':
				LK.getSound('YuraYura_tower').play();
				break;
			case 'sniper':
				LK.getSound('Sweat_tower').play();
				break;
			case 'splash':
				LK.getSound('Crush_tower').play();
				break;
			case 'slow':
				LK.getSound('MeltingPoint_tower').play();
				break;
			case 'poison':
				LK.getSound('Blue_tower').play();
				break;
			default:
				LK.getSound('InBloom_tower').play();
				break;
		}
		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) {
			towerPreview.visible = true;
			isDragging = true;
			towerPreview.towerType = tower.towerType;
			towerPreview.updateAppearance();
			// Apply the same offset as in move handler to ensure consistency when starting drag
			towerPreview.snapToGrid(x, y - CELL_SIZE * 1.5);
			break;
		}
	}
};
game.move = function (x, y, obj) {
	if (isDragging) {
		// Shift the y position upward by 1.5 tiles to show preview above finger
		towerPreview.snapToGrid(x, y - CELL_SIZE * 1.5);
	}
};
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) {
		isDragging = false;
		if (towerPreview.canPlace) {
			if (!wouldBlockPath(towerPreview.gridX, towerPreview.gridY)) {
				placeTower(towerPreview.gridX, towerPreview.gridY, towerPreview.towerType);
			} else {
				var notification = game.addChild(new Notification("Tower would block the path!"));
				notification.x = 2048 / 2;
				notification.y = grid.height - 50;
			}
		} else if (towerPreview.blockedByEnemy) {
			var notification = game.addChild(new Notification("Cannot build: Enemy in the way!"));
			notification.x = 2048 / 2;
			notification.y = grid.height - 50;
		} else if (towerPreview.visible) {
			var notification = game.addChild(new Notification("Cannot build here!"));
			notification.x = 2048 / 2;
			notification.y = grid.height - 50;
		}
		towerPreview.visible = false;
		if (isDragging) {
			var upgradeMenus = game.children.filter(function (child) {
				return child instanceof UpgradeMenu;
			});
			for (var i = 0; i < upgradeMenus.length; i++) {
				upgradeMenus[i].destroy();
			}
		}
	}
};
// Add start menu
var startMenu = new StartMenu();
game.addChild(startMenu);
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);
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;
game.update = function () {
	if (!gameStarted) {
		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("⚠️ GUNWOOK 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
				// Use exponential scaling for health
				var healthMultiplier = Math.pow(1.12, currentWave); // ~20% increase per wave
				enemy.maxHealth = Math.round(enemy.maxHealth * healthMultiplier);
				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("Gunwook 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)) {
			// Play different sound based on enemy type when stealing durian
			if (enemy.isBoss) {
				// Special sound for Gunwook boss stealing durian
				LK.getSound('enemy_gunwook_steal_the_durian').play();
			} else {
				// Regular sound for normal enemies stealing durian
				LK.getSound('enemy_steal_a_durian').play();
			}
			// 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) {
				// Wait 3 seconds before playing game over sound and showing menu
				LK.setTimeout(function () {
					// Play game over sound
					LK.getSound('game_over').play();
					// Show custom defeat menu instead of automatic game over
					var defeatMenu = new DefeatMenu();
					game.addChild(defeatMenu);
				}, 3000);
				return; // Stop game loop execution
			}
		}
	}
	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) {
		// Update local records for win
		var records = storage.records || {
			bestWave: 0,
			bestScore: 0,
			totalGames: 0
		};
		records.totalGames = (records.totalGames || 0) + 1;
		if (currentWave > (records.bestWave || 0)) {
			records.bestWave = currentWave;
		}
		if (score > (records.bestScore || 0)) {
			records.bestScore = score;
		}
		storage.records = records;
		LK.showYouWin();
	}
};

===================================================================
--- original.js
+++ change.js
@@ -2329,9 +2329,9 @@
 				}
 				// Apply tower-specific bullet tinting
 				switch (self.id) {
 					case 'rapid':
-						bullet.children[0].tint = 0x00AAFF;
+						bullet.children[0].tint = 0xff8da1;
 						break;
 					case 'sniper':
 						bullet.children[0].tint = 0xFF5500;
 						break;