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

/**** 
* Classes
****/ 
// Centralized cleanup system for all game elements
// cleanupAfterWave function removed - no longer needed
var Bird = Container.expand(function () {
	var self = Container.call(this);
	var birdGraphics = self.attachAsset('crow', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.speed = 3 + Math.random() * 2; // Random speed between 3 and 5
	// Birds now spawn from top and move downward only
	// Restrict birds to spawn only on left and right sides, avoiding middle section and screen edges
	var screenWidth = 2048;
	var edgeMargin = 100; // Margin from screen edges
	var middleStart = screenWidth * 0.25; // 25% from left (reduced from 30%)
	var middleEnd = screenWidth * 0.75; // 75% from left (increased from 70%)
	if (Math.random() < 0.5) {
		// Spawn on left side (with margin from edge to 25% of screen width)
		self.x = edgeMargin + Math.random() * (middleStart - edgeMargin);
	} else {
		// Spawn on right side (75% to screen width minus margin)
		self.x = middleEnd + Math.random() * (screenWidth - middleEnd - edgeMargin);
	}
	self.y = -100; // Start above the screen
	self.update = function () {
		self.y += self.speed; // Move downward only
		// Keep crows within screen boundaries with larger margins
		var screenMargin = 120; // Increased margin from screen edge to prevent crows getting too close
		if (self.x < screenMargin) {
			self.x = screenMargin; // Prevent going off left edge
		}
		if (self.x > 2048 - screenMargin) {
			self.x = 2048 - screenMargin; // Prevent going off right edge
		}
		// Check safe zone boundaries (avoid tower placement and UI areas)
		var safeZoneLeft = 150 + 11 * 76; // Start of tower placement column
		var safeZoneRight = safeZoneLeft + 2 * 76; // End of tower placement column (2 cells wide)
		var safeZoneTop = 200; // Top of tower placement area
		var safeZoneBottom = safeZoneTop + 29 * 76; // Bottom of tower placement area
		// Avoid tower placement area and enemy spawn/goal areas
		if (self.x >= safeZoneLeft && self.x <= safeZoneRight && self.y >= safeZoneTop && self.y <= safeZoneBottom) {
			// Destroy bird if it enters tower/enemy area
			self.destroy();
			return;
		}
		// Destroy bird when it goes off bottom of screen
		if (self.y > 2832) {
			self.destroy();
		}
	};
	// Override hit detection to increase touch sensitivity
	self.hitArea = new Rectangle(-50, -50, 180, 180); // Expand hit area from 90x90 to 180x180
	self.down = function () {
		if (currentWave > 4) {
			setGold(gold + 4); // Award 4 gold for each crow destroyed after wave 4
		} else {
			setGold(gold + 2); // Award 2 gold for each crow destroyed
		}
		// Show gold animation like when enemies die
		var goldAmount = currentWave > 4 ? 4 : 2; // Determine gold amount based on wave
		var goldIndicator = new GoldIndicator(goldAmount, self.x, self.y);
		game.addChild(goldIndicator);
		// Create small fireworks-like particles when crow dies
		var particleCount = 8; // Small number of particles
		for (var i = 0; i < particleCount; i++) {
			var particle = getSmokeParticle();
			var particleGraphics = particle.smokeGraphics;
			// Small particle size
			particleGraphics.width = 4 + Math.random() * 8;
			particleGraphics.height = particleGraphics.width;
			// Black firework particles
			particleGraphics.tint = 0x000000;
			// Position particles around the crow
			var angle = i / particleCount * Math.PI * 2 + Math.random() * 0.5;
			var distance = 35 + Math.random() * 60; // Further increased initial distance for wider spread
			particle.x = self.x + Math.cos(angle) * distance;
			particle.y = self.y + Math.sin(angle) * distance;
			particle.alpha = 0.9;
			particle.scaleX = 0.8 + Math.random() * 0.4;
			particle.scaleY = particle.scaleX;
			game.addChild(particle);
			// Animate particles spreading outward like fireworks with increased spread
			var targetDistance = distance + 80 + Math.random() * 70; // Further increased spread distance for wider dispersion
			var targetX = self.x + Math.cos(angle) * targetDistance;
			var targetY = self.y + Math.sin(angle) * targetDistance - Math.random() * 30; // Increased vertical spread
			tween(particle, {
				x: targetX,
				y: targetY,
				alpha: 0,
				scaleX: particle.scaleX * 0.3,
				scaleY: particle.scaleY * 0.3
			}, {
				duration: 600 + Math.random() * 400,
				easing: tween.easeOut,
				onFinish: function onFinish() {
					// Particle cleanup handled by periodic systems
				}
			});
		}
		LK.getSound('kargas').play();
		self.destroy();
	};
	return self;
});
var Bullet = Container.expand(function (startX, startY, targetEnemy, damage, speed) {
	var self = Container.call(this);
	self.targetEnemy = targetEnemy;
	self.damage = damage || 10;
	self.speed = speed || 5;
	self.x = startX;
	self.y = startY;
	var bulletGraphics = self.attachAsset('bullet', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.update = function () {
		if (!self.targetEnemy || !self.targetEnemy.parent) {
			self.destroy();
			return;
		}
		var dx = self.targetEnemy.x - self.x;
		var dy = self.targetEnemy.y - self.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		// Add more concentrated bullet movement animation
		if (!self.animationPhase) {
			self.animationPhase = Math.random() * Math.PI * 2;
		}
		self.animationPhase += 0.3;
		// Apply animation reduction for splash bullets to minimize load
		var animationFactor = self.animationReductionFactor || 1.0; // Default to full animation
		var concentratedBounce = Math.sin(self.animationPhase) * 2 * animationFactor; // Reduced from larger values
		var concentratedSway = Math.cos(self.animationPhase * 0.7) * 1.5 * animationFactor; // More controlled sway
		// Apply subtle animation offset to bullet position
		var animatedX = self.x + concentratedSway;
		var animatedY = self.y + concentratedBounce;
		// Recalculate movement vectors using animated position for smoother trajectory
		dx = self.targetEnemy.x - animatedX;
		dy = self.targetEnemy.y - animatedY;
		distance = Math.sqrt(dx * dx + dy * dy);
		// Initialize lastWasIntersecting if not already set
		if (self.lastWasIntersecting === undefined) self.lastWasIntersecting = false;
		// Check for collision with target enemy - removed frame restriction for 60fps hit detection
		if (!self.lastWasIntersecting && distance < self.speed) {
			// Apply damage to target enemy (skip damage for findik enemies to make them immortal)
			if (self.targetEnemy.type !== 'findik') {
				// Normal damage for regular enemies AND fex enemies - fex can take damage and die
				self.targetEnemy.health -= self.damage;
				// Standard health clamping for regular enemies and fex enemies
				if (self.targetEnemy.health <= 0) {
					self.targetEnemy.health = 0;
				}
				// Update health bar for regular enemies and fex enemies
				if (self.targetEnemy.health > 0) {
					self.targetEnemy.healthBar.width = self.targetEnemy.health / self.targetEnemy.maxHealth * 70;
					// Ensure health bar is visible for damaged enemies
					if (self.targetEnemy.hasBeenDamaged) {
						self.targetEnemy.healthBar.visible = true;
						self.targetEnemy.healthBar.parent.children[0].visible = true; // healthBarOutline
						self.targetEnemy.healthBar.parent.children[1].visible = true; // healthBarBG
					}
				} else {
					self.targetEnemy.healthBar.width = 0;
				}
			} else {
				// Special handling for immortal enemies (only findik) - they take no damage
				// Fındık enemies are completely immune - bullets should not affect them at all
				if (self.targetEnemy.type === 'findik') {
					// Fındık enemies are completely immune to tower damage - no visual feedback
					// Bullet simply disappears without any effect
					// CRITICAL: Force health to stay at maximum
					self.targetEnemy.health = self.targetEnemy.maxHealth;
					// Force health bar to show full health
					if (self.targetEnemy.healthBar) {
						self.targetEnemy.healthBar.width = 70;
					}
				}
			}
			// Play youarekilling me sound on first successful bullet hit with delay
			// Only for default bullets and normal enemies
			if (canPlaySound('youarekillingme', 1200) && (!self.type || self.type === 'default') && self.targetEnemy.type === 'normal') {
				tween({}, {}, {
					duration: 1200,
					onFinish: function onFinish() {
						LK.getSound('youarekillingme').play();
					}
				});
			}
			// Track default bullet hits and play "it didn't hurt" sound on 7th hit (only for normal enemies)
			if ((!self.type || self.type === 'default') && !self.targetEnemy.isFlying && self.targetEnemy.type === 'normal') {
				defaultBulletHitCount++;
				// Play "it didn't hurt" sound only once on 7th default bullet hit with delay
				if (defaultBulletHitCount === 7 && canPlaySound('itdidnthurt', 1200)) {
					// Delay the sound by 1200ms for clear speech
					tween({}, {}, {
						duration: 1200,
						onFinish: function onFinish() {
							LK.getSound('itdidnthurt').play();
						}
					});
				}
			}
			// Track default bullet hits on swarm enemies for "you can't stop us" sound
			if ((!self.type || self.type === 'default') && !self.targetEnemy.isFlying && self.targetEnemy.type === 'swarm') {
				// Initialize separate counter for swarm enemies if it doesn't exist
				if (!window.swarmBulletHitCount) {
					window.swarmBulletHitCount = 0;
				}
				window.swarmBulletHitCount++;
				// Play "shoes" sound only once on first default bullet hit on swarm enemy
				if (window.swarmBulletHitCount === 1 && !window.shoesSoundPlayed) {
					window.shoesSoundPlayed = true;
					LK.getSound('shoes').play();
				}
				// Play "you can't stop us" sound only once on 10th default bullet hit on swarm enemy with delay
				if (window.swarmBulletHitCount === 10 && canPlaySound('youcantstopus', 1200)) {
					// Delay the sound by 1200ms for clear speech
					tween({}, {}, {
						duration: 1200,
						onFinish: function onFinish() {
							LK.getSound('youcantstopus').play();
							// Play browser sound 2 seconds after youcantstopus sound - only once per wave
							if (canPlaySound('browser', 2000)) {
								tween({}, {}, {
									duration: 2000,
									onFinish: function onFinish() {
										LK.getSound('browser').play();
										// Play tnk sound 5 seconds after browser sound
										tween({}, {}, {
											duration: 5000,
											onFinish: function onFinish() {
												LK.getSound('tnk').play();
												// Play borc sound 4 seconds after tnk sound
												tween({}, {}, {
													duration: 4000,
													onFinish: function onFinish() {
														LK.getSound('borc').play();
														// Play db sound 4 seconds after borc sound finishes
														tween({}, {}, {
															duration: 4000,
															onFinish: function onFinish() {
																LK.getSound('db').play();
															}
														});
													}
												});
											}
										});
									}
								});
							}
						}
					});
				}
			}
			// Removed browser sound for rapid bullet hits on swarm enemies - now only plays after youcantstopus sound
			// Play "you will never give up, will you?" sound only once on first rapid bullet hit with delay (only for normal enemies)
			if (self.type === 'rapid' && canPlaySound('youwillnevergiveup', 1200) && self.targetEnemy.type === 'normal') {
				// Delay the sound by 1200ms for clear speech
				tween({}, {}, {
					duration: 1200,
					onFinish: function onFinish() {
						LK.getSound('youwillnevergiveup').play();
					}
				});
			}
			// Track rapid bullet hits and play "gıdıklanıyorum" sound only once on 13th rapid bullet hit with delay (only for normal enemies)
			if (self.type === 'rapid' && !self.targetEnemy.isFlying && self.targetEnemy.type === 'normal') {
				// Increment rapid bullet hit counter (using defaultBulletHitCount as rapid bullet counter)
				if (!window.rapidBulletHitCount) {
					window.rapidBulletHitCount = 0;
				}
				window.rapidBulletHitCount++;
				// Play "gıdıklanıyorum" sound only once on 13th rapid bullet hit with delay
				if (window.rapidBulletHitCount === 13 && canPlaySound('gidiklaniyorum', 1400)) {
					// Delay the sound by 1400ms for clear speech
					tween({}, {}, {
						duration: 1400,
						onFinish: function onFinish() {
							LK.getSound('gidiklaniyorum').play();
						}
					});
				}
			}
			// Splash bullet hit detection - goddamit sound now plays on bullet creation instead of hit
			if (self.type === 'splash' && !self.targetEnemy.isFlying && self.targetEnemy.type === 'normal') {
				// Sound is now played when bullet is created, not when it hits
			}
			// Blood animation removed for swarm enemies per requirements
			// Skip blood animation for flying enemies, boss enemies, swarm enemies, and immune enemies
			// No blood animation will be created for any bullet hits on swarm enemies
			if (false) {
				// Blood animation completely disabled for swarm enemies
			}
			// Apply special effects based on bullet type
			if (self.type === 'splash') {
				// Disable splash bullet effects for waves 12+ to prevent white screen
				if (currentWave >= 12) {
					// Skip splash effects for waves 12+
				} else {
					// Create optimized black smoke effects with reduced particle count
					var smokeCount = 1; // Always 1 to minimize particle load
					for (var smokeIdx = 0; smokeIdx < smokeCount; smokeIdx++) {
						var smokeParticle = getSmokeParticle();
						var smokeGraphics = smokeParticle.smokeGraphics;
						smokeGraphics.width = 12 + Math.random() * 15; // Smaller particles for less memory
						smokeGraphics.height = smokeGraphics.width;
						smokeGraphics.tint = 0x2a2a2a; // Dark smoke color
						smokeParticle.x = self.targetEnemy.x + (Math.random() - 0.5) * 50; // Reduced spread
						smokeParticle.y = self.targetEnemy.y + (Math.random() - 0.5) * 50; // Reduced spread
						smokeParticle.alpha = 0.7 + Math.random() * 0.2; // Slightly more transparent
						smokeParticle.scaleX = 0.25 + Math.random() * 0.3; // Smaller scale
						smokeParticle.scaleY = 0.25 + Math.random() * 0.3; // Smaller scale
						game.addChild(smokeParticle);
						// Animate smoke with shorter duration for faster cleanup
						var targetY = smokeParticle.y - 60 - Math.random() * 30; // Reduced movement
						var targetX = smokeParticle.x + (Math.random() - 0.5) * 30; // Reduced movement
						tween(smokeParticle, {
							x: targetX,
							y: targetY,
							alpha: 0,
							scaleX: smokeParticle.scaleX * 2.0,
							// Reduced scaling
							scaleY: smokeParticle.scaleY * 2.0 // Reduced scaling
						}, {
							duration: 800 + Math.random() * 400,
							// Shorter duration for faster cleanup
							easing: tween.easeOut,
							onFinish: function onFinish() {
								// Particle cleanup now handled by periodic systems
							}
						});
					}
					// Visual splash effect removed - no green flash
					// 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;
								}
								// Play krk sound for immune enemies hit by splash tower bullets on 2nd hit - only once per wave
								if (otherEnemy.isImmune && self.type === 'splash') {
									if (typeof window.splashImmuneHitCounter === 'undefined') {
										window.splashImmuneHitCounter = 0;
									}
									window.splashImmuneHitCounter++;
									if (window.splashImmuneHitCounter === 2 && !window.krkSoundPlayedThisWave) {
										window.krkSoundPlayedThisWave = true;
										try {
											LK.getSound('krk').play();
										} catch (e) {
											console.log("Error playing krk sound:", e);
										}
									}
								}
								// Krk sound moved to splash tower bullet hit logic - not played here anymore
							}
						}
					}
				}
			} else if (self.type === 'slow') {
				// Disable slow tower visual effects for waves 12+ to prevent white screen
				if (currentWave >= 12) {
					// Skip slow visual effects for waves 12+ but keep damage
					var slowRadius = self.getRange();
					var affectedEnemies = [];
					// Find all enemies within slow radius from tower
					for (var i = 0; i < enemies.length; i++) {
						var nearbyEnemy = enemies[i];
						if (nearbyEnemy && nearbyEnemy.parent && nearbyEnemy.health > 0 && !nearbyEnemy.isFlying) {
							var dx = nearbyEnemy.x - self.x;
							var dy = nearbyEnemy.y - self.y;
							var distance = Math.sqrt(dx * dx + dy * dy);
							if (distance <= slowRadius) {
								affectedEnemies.push(nearbyEnemy);
							}
						}
					}
					// Apply damage without visual effects
					if (affectedEnemies.length > 0) {
						var damagedEnemy = affectedEnemies[0];
						damagedEnemy.health -= self.damage;
						if (damagedEnemy.health <= 0) {
							damagedEnemy.health = 0;
						} else {
							damagedEnemy.healthBar.width = damagedEnemy.health / damagedEnemy.maxHealth * 70;
						}
					}
					// Apply slow effect without visual indicators
					for (var i = 0; i < affectedEnemies.length; i++) {
						var affectedEnemy = affectedEnemies[i];
						if (affectedEnemy.type !== 'fex') {
							var slowPct = 0.25;
							if (self.level !== undefined) {
								var slowLevels = [0.25, 0.3, 0.32, 0.35, 0.37, 0.4];
								var idx = Math.max(0, Math.min(5, self.level - 1));
								slowPct = slowLevels[idx];
							}
							if (!affectedEnemy.slowed) {
								affectedEnemy.originalSpeed = affectedEnemy.speed;
								affectedEnemy.speed *= 1 - slowPct;
								affectedEnemy.slowed = true;
								affectedEnemy.slowDuration = 180;
							} else {
								affectedEnemy.slowDuration = 180;
							}
						}
					}
					return; // Exit early for waves 12+
				}
				// Get the range from the source tower for slow effect area
				var slowRadius = self.sourceTower ? self.sourceTower.getRange() : CELL_SIZE * 3.5; // Use tower's actual range
				var affectedEnemies = [];
				// Find all enemies within slow radius from impact point
				for (var i = 0; i < enemies.length; i++) {
					var nearbyEnemy = enemies[i];
					if (nearbyEnemy && nearbyEnemy.parent && nearbyEnemy.health > 0) {
						var dx = nearbyEnemy.x - self.targetEnemy.x; // Use impact point as center
						var dy = nearbyEnemy.y - self.targetEnemy.y; // Use impact point as center
						var distance = Math.sqrt(dx * dx + dy * dy);
						if (distance <= slowRadius) {
							affectedEnemies.push(nearbyEnemy);
						}
					}
				}
				// Apply slow effect to all affected enemies
				for (var i = 0; i < affectedEnemies.length; i++) {
					var affectedEnemy = affectedEnemies[i];
					// Create reduced visual slow effect for each affected enemy
					var slowEffect = new EffectIndicator(affectedEnemy.x, affectedEnemy.y, 'slow');
					game.addChild(slowEffect);
					// Apply slow effect
					// Make slow percentage scale with source tower level if available
					var slowPct = 0.25;
					if (self.sourceTowerLevel !== undefined) {
						// Scale: 25% at level 1, 30% at 2, 32% at 3, 35% at 4, 37% at 5, 40% at 6
						var slowLevels = [0.25, 0.3, 0.32, 0.35, 0.37, 0.4];
						var idx = Math.max(0, Math.min(5, self.sourceTowerLevel - 1));
						slowPct = slowLevels[idx];
					}
					if (!affectedEnemy.slowed) {
						affectedEnemy.originalSpeed = affectedEnemy.speed;
						affectedEnemy.speed *= 1 - slowPct; // Slow by X%
						affectedEnemy.slowed = true;
						affectedEnemy.slowDuration = 180; // 3 seconds at 60 FPS
					} else {
						affectedEnemy.slowDuration = 180; // Reset duration
					}
				}
			} else if (self.type === 'poison') {
				// Handle poison bullets hitting immune enemies
				if (self.targetEnemy.isImmune) {
					// Play mask sound for immune enemies hit by poison bullets - only once per wave
					if (!window.maskSoundPlayedThisWave) {
						window.maskSoundPlayedThisWave = true;
						LK.getSound('mask').play();
					}
				} else {
					// Increment poison bullet hit counter for tracking (only for normal enemies)
					if (!self.targetEnemy.isFlying && self.targetEnemy.type === 'normal') {
						poisonBulletHitCount++;
						// Play gogogo sound only once for poison bullets on first poison bullet hit (exclude fast enemies from wave 5)
						if (poisonBulletHitCount === 1 && canPlaySound('gogogo', 1200) && !(self.targetEnemy.type === 'fast' && self.targetEnemy.waveNumber === 5)) {
							LK.getSound('gogogo').play();
						}
						// Play whofarted sound only once on second poison bullet hit with delay (exclude fast enemies from wave 5)
						if (poisonBulletHitCount === 2 && canPlaySound('whofarted', 800) && !(self.targetEnemy.type === 'fast' && self.targetEnemy.waveNumber === 5)) {
							// Delay the whofarted sound by 800ms
							tween({}, {}, {
								duration: 800,
								onFinish: function onFinish() {
									LK.getSound('whofarted').play();
								}
							});
						}
					}
					// Play poison bullet hit sound every 3rd hit for non-flying enemies (separate from the counter above)
					if (!self.targetEnemy.isFlying) {
						// Initialize global poison hit counter if not exists
						if (!window.globalPoisonHitCount) {
							window.globalPoisonHitCount = 0;
						}
						window.globalPoisonHitCount++;
						// Play poison bullet hit sound every 3rd hit
						if (window.globalPoisonHitCount % 3 === 0) {
							LK.getSound('poison_bullet_hit').play();
						}
					}
					// Coughing animation removed for poison bullets
					// Poison bullet impact animation removed
					// 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') {
				// Sniper hit - play becareful sound only once on first contact (only for normal enemies)
				if (!beCarefulSoundPlayed && self.targetEnemy.type === 'normal') {
					beCarefulSoundPlayed = true;
					LK.getSound('becareful').play();
				}
				// Track sniper bullet hits and play "sniperr" sound only once on 3rd hit (only for normal enemies)
				if (!self.targetEnemy.isFlying && self.targetEnemy.type === 'normal') {
					sniperBulletHitCount++;
					// Play "sniperr" sound only once on 3rd sniper bullet hit
					if (sniperBulletHitCount === 3 && canPlaySound('sniperr', sniperrSoundCooldown)) {
						LK.getSound('sniperr').play();
					}
					// Play "keepmoving" sound only once on 4th sniper bullet hit
					if (sniperBulletHitCount === 4 && canPlaySound('keepmoving', keepMovingSoundCooldown)) {
						LK.getSound('keepmoving').play();
					}
					// Removed gogogo sound for sniper bullet hits on normal enemies
					// if (sniperBulletHitCount === 7 && !gogogoSniperSoundPlayed) {
					//	gogogoSniperSoundPlayed = true;
					//	LK.getSound('gogogo').play();
					// }
				}
				// Shy sound logic moved to sniper tower fire method to ensure it only triggers for sniper towers
			}
			self.lastWasIntersecting = distance < self.speed; // Update last intersection state
			self.destroy();
		} else {
			var angle = Math.atan2(dy, dx);
			// Apply concentrated movement with subtle animation
			var baseMovementX = Math.cos(angle) * self.speed;
			var baseMovementY = Math.sin(angle) * self.speed;
			// Add very subtle concentrated bouncing to movement with animation reduction factor
			var animationFactor = self.animationReductionFactor || 1.0; // Default to full animation
			var concentratedBounceX = Math.sin(self.animationPhase * 1.2) * 0.8 * animationFactor; // Much smaller bounce
			var concentratedBounceY = Math.cos(self.animationPhase * 1.5) * 0.6 * animationFactor; // Reduced bounce
			self.x += baseMovementX + concentratedBounceX;
			self.y += baseMovementY + concentratedBounceY;
		}
	};
	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 = false;
					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;
					}
					// Hide direction arrows by not displaying them
					while (debugArrows.length > 0) {
						self.removeChild(debugArrows.pop());
					}
					// Direction arrows are now hidden
					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);
	};
});
// 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 = 0xFF0000;
			effectGraphics.width = effectGraphics.height = CELL_SIZE;
			break;
		case 'poison':
			effectGraphics.tint = 0x00FFAA;
			effectGraphics.width = effectGraphics.height = CELL_SIZE;
			break;
		case 'sniper':
			effectGraphics.tint = 0xFF5500;
			effectGraphics.width = effectGraphics.height = CELL_SIZE;
			break;
	}
	effectGraphics.alpha = 0.7;
	self.alpha = 0;
	// Animate the effect with reduced animation
	tween(self, {
		alpha: 0.6,
		scaleX: 1.2,
		scaleY: 1.2
	}, {
		duration: 100,
		easing: tween.easeOut,
		onFinish: function onFinish() {
			tween(self, {
				alpha: 0,
				scaleX: 1.4,
				scaleY: 1.4
			}, {
				duration: 150,
				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 'fast':
			self.speed *= 1.6; // Reduced speed from 2x to 1.6x
			self.maxHealth = 100;
			break;
		case 'immune':
			self.isImmune = true;
			self.maxHealth = 80;
			break;
		case 'flying':
			self.isFlying = true;
			self.maxHealth = 220;
			break;
		case 'swarm':
			self.maxHealth = 50; // Weaker enemies
			break;
		case 'blue':
			self.maxHealth = 150; // Medium health
			self.speed *= 1.5; // Faster than normal
			break;
		case 'vex':
			self.maxHealth = 200; // Stronger than blue enemies
			self.speed *= 2.0; // Much faster movement
			break;
		case 'rat':
			self.maxHealth = 950; // Set rat enemy health to 950
			self.speed *= 0.8; // Slightly slower to reduce animation load
			break;
		case 'big':
			self.maxHealth = 300; // Much stronger than normal enemies
			self.speed *= 0.7; // Slower movement
			break;
		case 'kırık':
			self.maxHealth = 100; // Normal health like other enemies
			self.speed *= 1.5; // Faster movement (increased from 0.8 to 1.5)
			// Removed immortal property - now mortal
			break;
		case 'normal':
		default:
			// Normal enemy uses default values
			break;
	}
	if (currentWave === 7 && type !== 'swarm') {
		self.isBoss = true;
		// Boss enemies have 10x health and are larger
		self.maxHealth *= 10;
		// Faster speed for bosses
		self.speed = self.speed * 1.2;
	}
	self.health = self.maxHealth;
	// Get appropriate asset for this enemy type
	var assetId = 'enemy';
	if (self.type === 'bigboss') {
		assetId = 'bigboss';
	} else if (self.type === 'blue') {
		assetId = 'enemy_blue';
	} else if (self.type === 'vex') {
		assetId = 'enemy_vex';
	} else if (self.type === 'rat') {
		assetId = 'enemy_rat';
	} else if (self.type === 'kırık') {
		assetId = 'enemy_kirik';
	} else if (self.type !== 'normal') {
		assetId = 'enemy_' + self.type;
	}
	var enemyGraphics = self.attachAsset(assetId, {
		anchorX: 0.5,
		anchorY: 0.5,
		scaleX: self.type === 'rat' ? 1.30 : self.type === 'big' ? 0.9 : 1.25,
		scaleY: self.type === 'rat' ? 1.30 : self.type === 'big' ? 0.9 : 1.25
	});
	// Adjust rat enemy graphic position to align with feet
	if (self.type === 'rat') {
		enemyGraphics.x = -8; // Shift rat graphic slightly to the left
	}
	// Add walking feet for normal, swarm, blue, and kırık enemies only (no feet for boss enemies)
	self.leftFoot = null;
	self.rightFoot = null;
	if ((self.type === 'normal' || self.type === 'swarm' || self.type === 'blue' || self.type === 'vex' || self.type === 'rat' || self.type === 'kırık') && !self.isBoss) {
		// Adjust foot size and asset based on enemy type
		var footWidth, footHeight, footSpacing, footAsset;
		if (self.type === 'vex') {
			// Vex gets special feet - start smaller before entering game area
			footWidth = 16;
			footHeight = 12;
			footSpacing = 18;
			footAsset = 'vexFeet';
		} else if (self.type === 'rat') {
			// Rat enemy gets simplified feet for better performance
			footWidth = 16;
			footHeight = 12;
			footSpacing = 14;
			footAsset = 'walkingFeet';
		} else if (self.type === 'kırık') {
			// Kırık enemy gets bigger feet
			footWidth = 24;
			footHeight = 18;
			footSpacing = 20;
			footAsset = 'walkingFeet';
		} else {
			// Regular feet for other enemies
			footWidth = 18;
			footHeight = 13;
			footSpacing = 15;
			footAsset = 'walkingFeet';
		}
		var footYPosition = 35;
		// Create walking feet as regular Container objects (not particles)
		self.leftFoot = new Container();
		var leftFootGraphics = self.leftFoot.attachAsset(footAsset, {
			anchorX: 0.5,
			anchorY: 0.5
		});
		leftFootGraphics.width = footWidth;
		leftFootGraphics.height = footHeight;
		leftFootGraphics.tint = 0x000000; // Black color for walking feet
		self.rightFoot = new Container();
		var rightFootGraphics = self.rightFoot.attachAsset(footAsset, {
			anchorX: 0.5,
			anchorY: 0.5
		});
		rightFootGraphics.width = footWidth;
		rightFootGraphics.height = footHeight;
		rightFootGraphics.tint = 0x000000; // Black color for walking feet
		// Position feet relative to enemy size
		self.leftFoot.x = -footSpacing; // Position to the left
		self.leftFoot.y = footYPosition; // Position lower at bottom of enemy
		self.addChild(self.leftFoot);
		self.rightFoot.x = footSpacing; // Position to the right
		self.rightFoot.y = footYPosition; // Position lower at bottom of enemy
		self.addChild(self.rightFoot);
		// Initialize foot animation variables
		self.leftFootPhase = 0;
		self.rightFootPhase = Math.PI; // Start opposite phase for alternating steps
	}
	// Scale up boss enemies
	if (self.isBoss) {
		if (self.type === 'bigboss') {
			enemyGraphics.scaleX = 1.8;
			enemyGraphics.scaleY = 1.8;
		} else {
			enemyGraphics.scaleX = 1.3;
			enemyGraphics.scaleY = 1.3;
		}
	}
	// 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;
	}*/
	// Flying enemies no longer use shadows for performance optimization
	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;
	// Initialize health bar visibility - hide by default until damage is taken
	healthBarOutline.visible = false;
	healthBarBG.visible = false;
	healthBar.visible = false;
	self.hasBeenDamaged = false; // Track if enemy has taken damage
	// Initialize kırık enemy special properties
	if (self.type === 'kırık') {
		// Health bar will show normally when damaged like other enemies
		self.kırıkPhase = 'goingToTabela'; // 'goingToTabela' or 'returningToStart'
		// Set tabela position as target (one cell down and one cell left from previous position)
		self.tabelaX = (2048 - 360 - 76) / CELL_SIZE; // Convert pixel position to grid
		self.tabelaY = (2732 / 2 + 76 - (200 - CELL_SIZE * 4)) / CELL_SIZE; // Convert pixel position to grid
		self.startX = self.currentCellX; // Remember starting position
		self.startY = self.currentCellY;
	}
	// Initialize walking animation variables
	self.walkAnimationPhase = Math.random() * Math.PI * 2; // Random starting phase for each enemy
	self.walkAnimationSpeed = 0.15; // Animation speed
	self.walkBobAmount = 3; // How much to bob up and down
	self.lastWalkingState = false;
	self.isCurrentlyMakingSound = false; // Flag to limit footstep sounds
	self.hasPlayedFirstPoisonSound = false; // Track if gogogo sound has been played for this enemy
	self.update = function () {
		// Clean up targeting arrays periodically
		if (LK.ticks % 900 === 0) {
			// Every 15 seconds
			if (self.bulletsTargetingThis) {
				self.bulletsTargetingThis = self.bulletsTargetingThis.filter(function (bullet) {
					return bullet && bullet.parent && bullet.targetEnemy === self;
				});
			}
		}
		// Track last health for damage animation
		if (self.lastHealth === undefined) {
			self.lastHealth = self.health;
		}
		// Add +2 gold to the player when a vex enemy appears
		if (self.type === 'vex' && !self.goldAdded) {
			setGold(gold + 2);
			self.goldAdded = true; // Ensure gold is only added once per vex enemy
			// Show mercy message when vex enemy appears
			if (!self.mercyMessageShown) {
				self.mercyMessageShown = true;
				// Create mercy message text
				var mercyText = new Text2("o askere merhamet et ve onu yükselt", {
					size: 80,
					fill: 0xFFFFFF,
					weight: 800
				});
				mercyText.anchor.set(0.5, 0.5);
				mercyText.x = 2048 / 2;
				mercyText.y = 2732 / 2;
				mercyText.alpha = 0;
				game.addChild(mercyText);
				// Find and animate the default tower
				var defaultTower = null;
				for (var i = 0; i < towers.length; i++) {
					if (towers[i].id === 'default') {
						defaultTower = towers[i];
						break;
					}
				}
				// Store references globally for touch handler
				window.vexMercyText = mercyText;
				window.vexAnimatedTower = defaultTower;
				window.vexAnimationActive = true;
				// Start tower pulsing animation if default tower exists
				if (defaultTower) {
					var _animateTowerPulse = function animateTowerPulse() {
						if (window.vexAnimationActive && defaultTower && defaultTower.parent) {
							tween(defaultTower, {
								scaleX: 1.3,
								scaleY: 1.3
							}, {
								duration: 800,
								easing: tween.easeInOut,
								onFinish: function onFinish() {
									if (window.vexAnimationActive && defaultTower && defaultTower.parent) {
										tween(defaultTower, {
											scaleX: 1.0,
											scaleY: 1.0
										}, {
											duration: 800,
											easing: tween.easeInOut,
											onFinish: function onFinish() {
												if (window.vexAnimationActive) {
													_animateTowerPulse(); // Continue pulsing
												}
											}
										});
									}
								}
							});
						}
					};
					_animateTowerPulse(); // Start the pulsing animation
				}
				// Fade in the message
				tween(mercyText, {
					alpha: 1
				}, {
					duration: 1000,
					easing: tween.easeInOut,
					onFinish: function onFinish() {
						// Keep message visible for 10 seconds, then fade out
						tween({}, {}, {
							duration: 10000,
							// 10 seconds
							onFinish: function onFinish() {
								// Stop animation and clean up
								window.vexAnimationActive = false;
								if (window.vexAnimatedTower) {
									tween.stop(window.vexAnimatedTower, {
										scaleX: true,
										scaleY: true
									});
									tween(window.vexAnimatedTower, {
										scaleX: 1.0,
										scaleY: 1.0
									}, {
										duration: 300,
										easing: tween.easeOut
									});
								}
								tween(mercyText, {
									alpha: 0
								}, {
									duration: 1000,
									easing: tween.easeInOut,
									onFinish: function onFinish() {
										if (mercyText.parent) {
											mercyText.parent.removeChild(mercyText);
										}
										// Clean up global references
										window.vexMercyText = null;
										window.vexAnimatedTower = null;
										window.vexAnimationActive = false;
									}
								});
							}
						});
					}
				});
			}
		}
		// Check if enemy took damage this frame (blood animation now handled in Bullet class)
		// Initialize lastWasIntersecting if not already set
		if (self.lastWasIntersecting === undefined) self.lastWasIntersecting = false;
		// Check for collision with bullets
		if (!self.lastWasIntersecting && self.lastHealth > self.health) {
			// Show health bar when enemy takes damage for the first time
			if (!self.hasBeenDamaged) {
				self.hasBeenDamaged = true;
				healthBarOutline.visible = true;
				healthBarBG.visible = true;
				healthBar.visible = true;
			}
		}
		// Hide health bar when enemy is at full health
		if (self.health >= self.maxHealth && self.hasBeenDamaged) {
			healthBarOutline.visible = false;
			healthBarBG.visible = false;
			healthBar.visible = false;
		} else if (self.hasBeenDamaged && self.health < self.maxHealth) {
			// Keep health bar visible when damaged but not at full health
			healthBarOutline.visible = true;
			healthBarBG.visible = true;
			healthBar.visible = true;
		}
		// Update last health
		self.lastWasIntersecting = self.lastHealth > self.health; // Update last intersection state
		self.lastHealth = self.health;
		if (self.health <= 0) {
			self.health = 0;
			self.healthBar.width = 0;
		}
		// Handle slow effect
		// Immune enemies can now be slowed and poisoned like other enemies
		{
			// Handle slow effect
			if (self.slowed) {
				// Check if enemy is still within range of any slow tower
				var stillInSlowRange = false;
				for (var t = 0; t < towers.length; t++) {
					var tower = towers[t];
					if (tower.id === 'slow') {
						var dx = tower.x - self.x;
						var dy = tower.y - self.y;
						var distance = Math.sqrt(dx * dx + dy * dy);
						if (distance <= tower.getRange()) {
							stillInSlowRange = true;
							break;
						}
					}
				}
				// If not in range of any slow tower, immediately end slow effect
				if (!stillInSlowRange) {
					self.speed = self.originalSpeed;
					self.slowed = false;
					self.slowEffect = false;
					// Reset tint immediately when exiting slow area
					if (!self.poisoned) {
						enemyGraphics.tint = 0xFFFFFF; // Reset tint
					}
				} else {
					// 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) {
			// Only show slow effect tint when both poisoned and slowed
			enemyGraphics.tint = 0xFF0000;
		} else if (self.slowed) {
			enemyGraphics.tint = 0xFF0000;
		} else {
			enemyGraphics.tint = 0xFFFFFF;
		}
		// Walking animation logic - enhanced for realism (disabled for flying enemies)
		// Check if enemy is on screen (has appeared) for animation and sound
		var isOnScreen = self.currentCellY >= -1; // Enemy is visible or about to be visible
		var isCurrentlyWalking = isOnScreen && !self.isFlying && (self.currentTarget && (self.currentTarget.x !== self.currentCellX || self.currentTarget.y !== self.currentCellY) || self.currentCellY < 4);
		// Add vex enemy support for walking animation - vex enemies should sway during ALL movement phases including returningToSpawn
		if (self.type === 'vex' && isOnScreen && !self.isFlying) {
			// Vex enemies walk normally like other enemies during all movement phases
			// Ensure they're always considered to be walking when on screen and not flying
			// This includes movingDown, movingRight, waiting, returningToSpawn phases
			// CRITICAL: Force walking animation even when switched to vx visual
			isCurrentlyWalking = true;
			// Additional force for vx visual state
			if (self.vexPhase === 'waiting' || self.vexPhase === 'returningToSpawn') {
				isCurrentlyWalking = true;
				shouldAnimate = true;
			}
		}
		// Batch walking animations - only animate every 3rd frame when many enemies
		// Exception: vex enemies always animate smoothly regardless of enemy count
		var shouldAnimate = enemies.length <= 15 || (LK.ticks + self.waveNumber) % 3 === 0;
		if (self.type === 'vex') {
			shouldAnimate = true; // Always animate vex enemies for smooth movement
		}
		// CRITICAL: Optimized Vex sway animation system for better performance
		if (self.type === 'vex' && self.vexPhase === 'waiting' && self.children[0] && self.children[0].texture && self.children[0].texture.baseTexture && self.children[0].texture.baseTexture.imageUrl && self.children[0].texture.baseTexture.imageUrl.includes('vx')) {
			// DISABLE main walking animation for vx visual state
			isCurrentlyWalking = false;
			shouldAnimate = false;
			// Initialize optimized vx swaying animation system - only update every 4 frames
			if (!self.vxSwayAnimation) {
				self.vxSwayAnimation = true;
				self.vxSwayPhase = Math.random() * Math.PI * 2;
				self.vxSwayTimer = 0;
				self.vxSwayDirection = 1; // Direction multiplier for swaying
				self.vxSwayActive = true; // Set to true to activate swaying
				self.vxLastUpdateFrame = LK.ticks; // Track last update frame
			}
			// PERFORMANCE OPTIMIZATION: Only update sway animation every 4 frames instead of every frame
			if (LK.ticks - self.vxLastUpdateFrame >= 4) {
				self.vxLastUpdateFrame = LK.ticks;
				self.vxSwayTimer += 4; // Increment by frames skipped
				// Apply optimized swaying animation with reduced frequency
				if (self.children[0] && self.vxSwayAnimation && self.vxSwayActive) {
					// Update phase with reduced increment for smoother but less frequent updates
					self.vxSwayPhase += 0.08; // Reduced from 0.18 to 0.08 for better performance
					// Calculate new sway position with reduced amplitude for less intensive animation
					var swayX = Math.sin(self.vxSwayPhase) * 20; // Reduced from 35 to 20
					var swayY = Math.sin(self.vxSwayPhase * 0.8) * 15; // Reduced from 25 to 15
					// Add subtle circular motion with reduced intensity
					var circularX = Math.cos(self.vxSwayPhase * 0.5) * 8; // Reduced from 12 to 8
					var circularY = Math.sin(self.vxSwayPhase * 0.7) * 5; // Reduced from 8 to 5
					// Combine swaying motions with reduced effect
					var finalX = swayX + circularX;
					var finalY = swayY + circularY;
					// Apply position directly with optimized timing
					self.children[0].x = finalX;
					self.children[0].y = finalY;
					// Ensure vx sprite stays upright during sway animation
					self.children[0].rotation = 0;
					self.children[0].targetRotation = 0;
				}
			}
			// Continue with other update logic - DO NOT return early
		}
		// Update walking animation if enemy is moving and on screen (but not for flying enemies)
		// Skip main walking animation for vx visual but continue with other logic
		if (!(self.type === 'vex' && self.vexPhase === 'waiting' && self.children[0] && self.children[0].texture && self.children[0].texture.baseTexture && self.children[0].texture.baseTexture.imageUrl && self.children[0].texture.baseTexture.imageUrl.includes('vx')) && isCurrentlyWalking && shouldAnimate) {
			// Advance animation phase based on actual movement speed for realistic timing
			var speedMultiplier = self.speed * 100; // Scale animation speed with movement speed
			// Special handling for vex enemies in vx visual state - use constant animation speed
			if (self.type === 'vex' && self.vexPhase === 'waiting' && self.children[0] && self.children[0].texture && self.children[0].texture.baseTexture && self.children[0].texture.baseTexture.imageUrl && self.children[0].texture.baseTexture.imageUrl.includes('vx')) {
				speedMultiplier = 150; // Constant animation speed for vx visual state
			}
			self.walkAnimationPhase += self.walkAnimationSpeed * speedMultiplier;
			// Create more realistic walking motion with multiple animation components
			var primaryBob = Math.sin(self.walkAnimationPhase) * self.walkBobAmount;
			var secondaryBob = Math.sin(self.walkAnimationPhase * 2) * (self.walkBobAmount * 0.3);
			var combinedBobOffset = primaryBob + secondaryBob;
			// Add subtle horizontal sway for more natural movement
			var horizontalSway = Math.sin(self.walkAnimationPhase * 0.5) * (self.walkBobAmount * 0.2);
			// Animate feet for normal, swarm, blue, vex, kırık and immune enemies only (no feet for boss enemies)
			// Special handling for vex enemies to ensure feet animation works during all phases
			if ((self.type === 'normal' || self.type === 'swarm' || self.type === 'blue' || self.type === 'vex' || self.type === 'kırık' || self.type === 'immune') && !self.isBoss && self.leftFoot && self.rightFoot) {
				// Keep feet at fixed positions with type-specific spacing
				var footYPos = self.type === 'rat' ? 40 : 35;
				var footSpacing;
				if (self.type === 'vex') {
					footSpacing = 18; // Special spacing for vex
				} else if (self.type === 'rat') {
					footSpacing = 25; // Wider spacing for rat
				} else if (self.type === 'kırık') {
					footSpacing = 20; // Wider spacing for kırık
				} else {
					footSpacing = 15; // Default spacing
				}
				self.leftFoot.y = footYPos; // Fixed position
				self.leftFoot.x = -footSpacing; // Fixed position
				self.rightFoot.y = footYPos; // Fixed position
				self.rightFoot.x = footSpacing; // Fixed position
				// Simplified foot animation - normal, vex, rat, kırık and immune enemies get foot animation, swarm enemies get no foot animation
				if (self.type === 'normal' || self.type === 'vex' || self.type === 'rat' || self.type === 'kırık' || self.type === 'immune') {
					// Update foot animation phases with type-specific multipliers
					var animationMultiplier;
					if (self.type === 'vex') {
						animationMultiplier = 3.0; // Increased animation for vex to make it more visible
					} else if (self.type === 'rat') {
						animationMultiplier = 0.8; // Much reduced animation for rat to prevent freezing
					} else if (self.type === 'kırık') {
						animationMultiplier = 3; // Faster animation for kırık
					} else if (self.type === 'immune') {
						animationMultiplier = 0.5; // Much reduced animation for immune to prevent lag
					} else {
						animationMultiplier = 2; // Default animation
					}
					self.leftFootPhase += self.walkAnimationSpeed * speedMultiplier * animationMultiplier;
					self.rightFootPhase += self.walkAnimationSpeed * speedMultiplier * animationMultiplier;
					// Use simple scaling animation with type-specific scaling
					var scaleMultiplier;
					if (self.type === 'vex') {
						scaleMultiplier = 0.15; // Reduced scaling for vex to prevent oversized feet
					} else if (self.type === 'rat') {
						scaleMultiplier = 0.15; // Much reduced scaling for rat feet to prevent freeze
					} else if (self.type === 'kırık') {
						scaleMultiplier = 0.25; // Reduced scaling for kırık (was 0.6)
					} else if (self.type === 'immune') {
						scaleMultiplier = 0.15; // Reduced scaling for immune (was 0.3)
					} else {
						scaleMultiplier = 0.2; // Reduced default scaling (was 0.4)
					}
					var leftFootScale = 1 + Math.abs(Math.sin(self.leftFootPhase)) * scaleMultiplier;
					var rightFootScale = 1 + Math.abs(Math.sin(self.rightFootPhase)) * scaleMultiplier;
					// Apply scaling animation using pooled animation objects for other enemy types
					if (self.type === 'immune') {
						// Direct scaling for immune enemies for simplicity
						self.leftFoot.scaleX = leftFootScale;
						self.leftFoot.scaleY = leftFootScale;
						self.rightFoot.scaleX = rightFootScale;
						self.rightFoot.scaleY = rightFootScale;
					} else if (self.type === 'rat') {
						// Use simplified animation for rat enemies like swarm enemies to prevent freeze
						// Direct scaling for rat enemies for simplicity like immune enemies
						self.leftFoot.scaleX = leftFootScale;
						self.leftFoot.scaleY = leftFootScale;
						self.rightFoot.scaleX = rightFootScale;
						self.rightFoot.scaleY = rightFootScale;
					} else {
						// Apply scaling animation using pooled animation objects for other enemy types
						if (self.leftFoot && !self.leftFoot.isAnimating) {
							self.leftFoot.isAnimating = true;
							createPooledAnimation(self.leftFoot, {
								scaleX: leftFootScale,
								scaleY: leftFootScale
							}, {
								duration: 100,
								easing: tween.easeInOut,
								onFinish: function onFinish() {
									if (self.leftFoot) {
										self.leftFoot.isAnimating = false;
									}
								}
							});
						}
						if (self.rightFoot && !self.rightFoot.isAnimating) {
							self.rightFoot.isAnimating = true;
							createPooledAnimation(self.rightFoot, {
								scaleX: rightFootScale,
								scaleY: rightFootScale
							}, {
								duration: 100,
								easing: tween.easeInOut,
								onFinish: function onFinish() {
									if (self.rightFoot) {
										self.rightFoot.isAnimating = false;
									}
								}
							});
						}
					}
					// Simplified rotation synchronization for immune enemies
					if (self.leftFoot && self.rightFoot && enemyGraphics.targetRotation !== undefined) {
						var targetFootRotation = enemyGraphics.targetRotation;
						if (self.type === 'immune') {
							// Direct rotation for immune enemies for simplicity
							self.leftFoot.rotation = targetFootRotation;
							self.rightFoot.rotation = targetFootRotation;
						} else {
							// Smoothly rotate feet to match enemy direction for other enemy types using pooled animations
							if (Math.abs(targetFootRotation - (self.leftFoot.rotation || 0)) > 0.05) {
								createPooledAnimation(self.leftFoot, {
									rotation: targetFootRotation
								}, {
									duration: 250,
									easing: tween.easeOut
								});
							}
							if (Math.abs(targetFootRotation - (self.rightFoot.rotation || 0)) > 0.05) {
								createPooledAnimation(self.rightFoot, {
									rotation: targetFootRotation
								}, {
									duration: 250,
									easing: tween.easeOut
								});
							}
						}
					}
				}
			}
			// Apply different animation intensity based on enemy type
			var animationIntensity = 1;
			switch (self.type) {
				case 'fast':
					animationIntensity = 0.8; // Reduced intensity for smoother movement
					break;
				case 'immune':
					animationIntensity = 0.3; // Much reduced movement for performance
					break;
				case 'swarm':
					animationIntensity = 0.5; // Simplified, reduced movement for swarm
					break;
			}
			// Apply boss scaling for more imposing movement
			if (self.isBoss) {
				animationIntensity *= 0.7; // Slower, more deliberate movement
				combinedBobOffset *= 1.2; // But with more weight
			}
			// Smooth animation for fast enemies using tween system
			if (self.type === 'fast') {
				var targetY = combinedBobOffset * animationIntensity;
				var targetX = horizontalSway * animationIntensity * 0.4; // Slightly more horizontal movement for natural walking
				// Use smooth tween animation for fast enemies to create fluid walking motion
				if (!self.fastAnimating) {
					self.fastAnimating = true;
					tween(enemyGraphics, {
						y: targetY,
						x: targetX
					}, {
						duration: 80,
						// Slightly longer duration for smoother movement
						easing: tween.easeInOut,
						// Smooth easing for natural motion
						onFinish: function onFinish() {
							self.fastAnimating = false;
						}
					});
				}
			} else if (self.type === 'swarm') {
				var targetY = combinedBobOffset * animationIntensity;
				var targetX = horizontalSway * animationIntensity * 0.3; // Much less horizontal movement
				// Use pooled animation for swarm enemies to create fluid walking motion like other enemies
				if (!self.swarmAnimating) {
					self.swarmAnimating = true;
					createPooledAnimation(enemyGraphics, {
						y: targetY,
						x: targetX
					}, {
						duration: 80,
						// Slightly longer duration for smoother movement
						easing: tween.easeInOut,
						// Smooth easing for natural motion
						onFinish: function onFinish() {
							self.swarmAnimating = false;
						}
					});
				}
			} else {
				// Normal complex animation for other enemy types
				var targetY = combinedBobOffset * animationIntensity;
				var targetX = horizontalSway * animationIntensity;
				// Use pooled animation for smoother animation instead of direct assignment
				if (!self.animatingMovement) {
					self.animatingMovement = true;
					createPooledAnimation(enemyGraphics, {
						y: targetY,
						x: targetX
					}, {
						duration: 50,
						easing: tween.easeOut,
						onFinish: function onFinish() {
							self.animatingMovement = false;
						}
					});
				}
				// Add slight rotation for more dynamic movement (not for swarm or fast)
				if (self.type !== 'swarm' && self.type !== 'fast') {
					var walkRotation = Math.sin(self.walkAnimationPhase * 1.5) * 0.05; // Very subtle rotation
					if (!self.animatingRotation) {
						self.animatingRotation = true;
						createPooledAnimation(enemyGraphics, {
							rotation: enemyGraphics.rotation + walkRotation
						}, {
							duration: 100,
							easing: tween.easeInOut,
							onFinish: function onFinish() {
								self.animatingRotation = false;
							}
						});
					}
				}
			}
			// Play footstep sound at specific points in the walking cycle when enemy is on screen (not for flying enemies)
			var walkCycle = Math.floor(self.walkAnimationPhase / (Math.PI / 2)) % 4;
			var lastWalkCycle = Math.floor((self.walkAnimationPhase - self.walkAnimationSpeed * speedMultiplier) / (Math.PI / 2)) % 4;
			// Play walking sound for non-flying enemies with reduced frequency to avoid audio overload
			if (walkCycle !== lastWalkCycle && walkCycle % 2 === 0 && !self.isCurrentlyMakingSound) {
				// Limit walking sounds based on enemy count to prevent audio chaos
				var enemyCount = enemies ? enemies.length : 0;
				var shouldPlaySound = false;
				// Play sound based on enemy count - fewer enemies = more sounds
				if (enemyCount <= 5) {
					shouldPlaySound = true; // Always play for small groups
				} else if (enemyCount <= 15) {
					shouldPlaySound = Math.random() < 0.3; // 30% chance for medium groups
				} else {
					shouldPlaySound = Math.random() < 0.1; // 10% chance for large groups
				}
				// Special handling for vex enemies - they should always play walking sound when moving
				if (self.type === 'vex' && isCurrentlyWalking) {
					shouldPlaySound = true; // Always play sound for vex enemies when they are walking
				}
				// Special handling for swarm enemies - they should also play walking sound when moving
				if (self.type === 'swarm' && isCurrentlyWalking) {
					shouldPlaySound = true; // Always play sound for swarm enemies when they are walking
				}
				if (shouldPlaySound) {
					self.isCurrentlyMakingSound = true;
					LK.getSound('walking').play();
					// Reset sound flag after a short delay
					tween({}, {}, {
						duration: 300,
						onFinish: function onFinish() {
							self.isCurrentlyMakingSound = false;
						}
					});
				}
			}
		} else {
			// Smoothly return to resting position when not walking (only for non-flying enemies)
			if (!self.isFlying && (enemyGraphics.y !== 0 || enemyGraphics.x !== 0)) {
				tween.stop(enemyGraphics, {
					y: true,
					x: true,
					rotation: true
				});
				tween(enemyGraphics, {
					y: 0,
					x: 0,
					rotation: enemyGraphics.targetRotation || 0
				}, {
					duration: 200,
					easing: tween.easeOut
				});
				self.animatingMovement = false;
				self.animatingRotation = false;
			}
			// Return feet to resting position for normal, swarm, blue, and kırık enemies only when not walking
			if ((self.type === 'normal' || self.type === 'swarm' || self.type === 'blue' || self.type === 'kırık') && !self.isBoss && self.leftFoot && self.rightFoot && !isCurrentlyWalking) {
				// Stop any ongoing animations
				tween.stop(self.leftFoot, {
					scaleX: true,
					scaleY: true
				});
				tween.stop(self.rightFoot, {
					scaleX: true,
					scaleY: true
				});
				// Reset animation flags with null checks
				if (self.leftFoot) {
					self.leftFoot.isAnimating = false;
				}
				if (self.rightFoot) {
					self.rightFoot.isAnimating = false;
				}
				// Return feet to normal scale and fixed positions, maintaining rotation sync - adjust for kırık and rat enemies
				var restFootYPos = 35;
				var restFootSpacing = self.type === 'kırık' ? 20 : self.type === 'rat' ? 25 : 15; // Wider spacing for kırık and rat enemies
				tween(self.leftFoot, {
					y: restFootYPos,
					x: -restFootSpacing,
					scaleX: 1,
					scaleY: 1,
					rotation: enemyGraphics.targetRotation || 0
				}, {
					duration: 200,
					easing: tween.easeOut
				});
				tween(self.rightFoot, {
					y: restFootYPos,
					x: restFootSpacing,
					scaleX: 1,
					scaleY: 1,
					rotation: enemyGraphics.targetRotation || 0
				}, {
					duration: 200,
					easing: tween.easeOut
				});
			}
		}
		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;
		// Stabilize sprite rotation to prevent tilting
		if (enemyGraphics && !self.isFlying) {
			// If no target rotation is set or rotation is very small, keep sprite upright
			if (!enemyGraphics.targetRotation || Math.abs(enemyGraphics.targetRotation) < 0.1) {
				enemyGraphics.rotation = 0;
				enemyGraphics.targetRotation = 0;
			}
			// Prevent extreme rotations that cause tilting
			if (Math.abs(enemyGraphics.rotation) > Math.PI) {
				enemyGraphics.rotation = enemyGraphics.rotation > 0 ? Math.PI : -Math.PI;
			}
		}
	};
	return self;
});
var FexEnemy = Container.expand(function () {
	var self = Container.call(this);
	self.type = 'fex';
	self.speed = 0.01;
	self.cellX = 0;
	self.cellY = 0;
	self.currentCellX = 0;
	self.currentCellY = 0;
	self.currentTarget = undefined;
	self.maxHealth = 950; // Set fex enemy health to 950
	self.health = self.maxHealth;
	self.bulletsTargetingThis = [];
	self.waveNumber = 4; // Only used in wave 4
	self.isFlying = false;
	self.isImmune = false;
	self.isBoss = false;
	self.speed = 0.009; // Set fex enemy walking speed to 0.009
	// Use dedicated fex asset
	var fexGraphics = self.attachAsset('enemy_fex', {
		anchorX: 0.5,
		anchorY: 0.5,
		scaleX: 1.25,
		scaleY: 1.25
	});
	// Add walking feet for fex enemy
	self.leftFoot = null;
	self.rightFoot = null;
	if (!self.isBoss) {
		var footWidth = 16;
		var footHeight = 12;
		var footSpacing = 15;
		var footAsset = 'walkingFeet';
		var footYPosition = 35;
		// Create walking feet as regular Container objects
		self.leftFoot = new Container();
		var leftFootGraphics = self.leftFoot.attachAsset(footAsset, {
			anchorX: 0.5,
			anchorY: 0.5
		});
		leftFootGraphics.width = footWidth;
		leftFootGraphics.height = footHeight;
		leftFootGraphics.tint = 0x000000; // Black color for walking feet
		self.rightFoot = new Container();
		var rightFootGraphics = self.rightFoot.attachAsset(footAsset, {
			anchorX: 0.5,
			anchorY: 0.5
		});
		rightFootGraphics.width = footWidth;
		rightFootGraphics.height = footHeight;
		rightFootGraphics.tint = 0x000000; // Black color for walking feet
		// Position feet relative to enemy size
		self.leftFoot.x = -footSpacing; // Position to the left
		self.leftFoot.y = footYPosition; // Position lower at bottom of enemy
		self.addChild(self.leftFoot);
		self.rightFoot.x = footSpacing; // Position to the right
		self.rightFoot.y = footYPosition; // Position lower at bottom of enemy
		self.addChild(self.rightFoot);
		// Initialize foot animation variables
		self.leftFootPhase = 0;
		self.rightFootPhase = Math.PI; // Start opposite phase for alternating steps
	}
	// Health bar setup
	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 = -fexGraphics.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;
	// Initialize health bar visibility - hide by default until damage is taken
	healthBarOutline.visible = false;
	healthBarBG.visible = false;
	healthBar.visible = false;
	self.hasBeenDamaged = false; // Track if enemy has taken damage
	// Initialize walking animation variables
	self.walkAnimationPhase = Math.random() * Math.PI * 2; // Random starting phase for each enemy
	self.walkAnimationSpeed = 0.15; // Animation speed
	self.walkBobAmount = 3; // How much to bob up and down
	self.lastWalkingState = false;
	self.isCurrentlyMakingSound = false; // Flag to limit footstep sounds
	self.hasPlayedFirstPoisonSound = false; // Track if gogogo sound has been played for this enemy
	self.update = function () {
		// Clean up targeting arrays periodically
		if (LK.ticks % 900 === 0) {
			// Every 15 seconds
			if (self.bulletsTargetingThis) {
				self.bulletsTargetingThis = self.bulletsTargetingThis.filter(function (bullet) {
					return bullet && bullet.parent && bullet.targetEnemy === self;
				});
			}
		}
		// Track last health for damage animation
		if (self.lastHealth === undefined) {
			self.lastHealth = self.health;
		}
		// Check if enemy took damage this frame
		if (self.lastHealth > self.health) {
			// Show health bar when enemy takes damage for the first time
			if (!self.hasBeenDamaged) {
				self.hasBeenDamaged = true;
				healthBarOutline.visible = true;
				healthBarBG.visible = true;
				healthBar.visible = true;
			}
		}
		// Hide health bar when enemy is at full health
		if (self.health >= self.maxHealth && self.hasBeenDamaged) {
			healthBarOutline.visible = false;
			healthBarBG.visible = false;
			healthBar.visible = false;
		} else if (self.hasBeenDamaged && self.health < self.maxHealth) {
			// Keep health bar visible when damaged but not at full health
			healthBarOutline.visible = true;
			healthBarBG.visible = true;
			healthBar.visible = true;
		}
		// Speed variation removed - fex enemy now moves at consistent speed
		// No irregular speed changes, maintains original speed throughout movement
		// Update last health
		self.lastHealth = self.health;
		if (self.health <= 0) {
			self.health = 0;
			self.healthBar.width = 0;
		} else {
			// Ensure health bar is properly updated when health > 0
			self.healthBar.width = self.health / self.maxHealth * 70;
		}
		// Additional validation to ensure fex enemy health is managed correctly
		if (self.health > 0 && self.health < self.maxHealth) {
			// Force health bar to be visible and correctly sized
			self.healthBar.visible = true;
			self.healthBar.width = Math.max(1, self.health / self.maxHealth * 70); // Ensure minimum width of 1
		}
		// Fex enemies are immune to slow effects but can still take damage
		// Force clear any slow effects that might have been applied
		if (self.slowed) {
			// Fex enemies cannot be slowed - immediately clear slow effect
			self.speed = self.originalSpeed || self.speed;
			self.slowed = false;
			self.slowDuration = 0;
			fexGraphics.tint = 0xFFFFFF; // Reset tint 
		}
		if (self.poisoned) {
			// 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;
				if (!self.slowed) {
					fexGraphics.tint = 0xFFFFFF; // Reset tint 
				}
			}
		}
		// Set tint based on effect status
		if (self.poisoned && self.slowed) {
			fexGraphics.tint = 0xFF0000;
		} else if (self.slowed) {
			fexGraphics.tint = 0xFF0000;
		} else {
			fexGraphics.tint = 0xFFFFFF;
		}
		// Walking animation logic
		var isOnScreen = self.currentCellY >= -1;
		var isCurrentlyWalking = isOnScreen && (self.currentTarget && (self.currentTarget.x !== self.currentCellX || self.currentTarget.y !== self.currentCellY) || self.currentCellY < 4);
		// Update walking animation if enemy is moving and on screen
		if (isCurrentlyWalking) {
			// Advance animation phase based on actual movement speed
			var speedMultiplier = self.speed * 100;
			self.walkAnimationPhase += self.walkAnimationSpeed * speedMultiplier;
			// Create realistic walking motion
			var primaryBob = Math.sin(self.walkAnimationPhase) * self.walkBobAmount;
			var secondaryBob = Math.sin(self.walkAnimationPhase * 2) * (self.walkBobAmount * 0.3);
			var combinedBobOffset = primaryBob + secondaryBob;
			// Add subtle horizontal sway for more natural movement
			var horizontalSway = Math.sin(self.walkAnimationPhase * 0.5) * (self.walkBobAmount * 0.2);
			// Animate feet if they exist
			if (self.leftFoot && self.rightFoot) {
				self.leftFoot.y = 35; // Fixed position
				self.leftFoot.x = -15; // Fixed position
				self.rightFoot.y = 35; // Fixed position
				self.rightFoot.x = 15; // Fixed position
				// Update foot animation phases
				self.leftFootPhase += self.walkAnimationSpeed * speedMultiplier * 2;
				self.rightFootPhase += self.walkAnimationSpeed * speedMultiplier * 2;
				// Use simple scaling animation
				var leftFootScale = 1 + Math.abs(Math.sin(self.leftFootPhase)) * 0.2;
				var rightFootScale = 1 + Math.abs(Math.sin(self.rightFootPhase)) * 0.2;
				// Apply scaling animation
				if (self.leftFoot && !self.leftFoot.isAnimating) {
					self.leftFoot.isAnimating = true;
					createPooledAnimation(self.leftFoot, {
						scaleX: leftFootScale,
						scaleY: leftFootScale
					}, {
						duration: 100,
						easing: tween.easeInOut,
						onFinish: function onFinish() {
							if (self.leftFoot) {
								self.leftFoot.isAnimating = false;
							}
						}
					});
				}
				if (self.rightFoot && !self.rightFoot.isAnimating) {
					self.rightFoot.isAnimating = true;
					createPooledAnimation(self.rightFoot, {
						scaleX: rightFootScale,
						scaleY: rightFootScale
					}, {
						duration: 100,
						easing: tween.easeInOut,
						onFinish: function onFinish() {
							if (self.rightFoot) {
								self.rightFoot.isAnimating = false;
							}
						}
					});
				}
			}
			// Apply animation to enemy body with enhanced swaying for limping effect
			var targetY = combinedBobOffset;
			var targetX = horizontalSway;
			// Add extra limping sway motion synchronized with foot animation - reduced amplitude
			var limpingSway = Math.sin(self.leftFootPhase * 0.8) * 3 + Math.cos(self.rightFootPhase * 0.6) * 2;
			targetX += limpingSway;
			if (!self.animatingMovement) {
				self.animatingMovement = true;
				createPooledAnimation(fexGraphics, {
					y: targetY,
					x: targetX
				}, {
					duration: 50,
					easing: tween.easeOut,
					onFinish: function onFinish() {
						self.animatingMovement = false;
					}
				});
			}
		}
		// Update health bar position
		healthBarOutline.y = healthBarBG.y = healthBar.y = -fexGraphics.height / 2 - 10;
	};
	return self;
});
var FindikEnemy = Container.expand(function () {
	var self = Container.call(this);
	self.type = 'findik';
	self.speed = 0.024; // Further increased walking speed (increased from 0.018 to 0.024)
	self.cellX = 0;
	self.cellY = 0;
	self.currentCellX = 0;
	self.currentCellY = 0;
	self.currentTarget = undefined;
	self.maxHealth = 1000;
	self.health = self.maxHealth;
	self.bulletsTargetingThis = [];
	self.waveNumber = 4; // Only used in wave 4
	self.isFlying = false;
	self.isImmune = false;
	self.isBoss = false;
	// Use dedicated findik asset
	var findikGraphics = self.attachAsset('enemy_findik', {
		anchorX: 0.5,
		anchorY: 0.5,
		scaleX: 1.25,
		scaleY: 1.25
	});
	// Fındık enemies don't have feet
	self.leftFoot = null;
	self.rightFoot = null;
	// Health bar setup
	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 = -findikGraphics.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;
	// Initialize health bar visibility - hide by default until damage is taken
	healthBarOutline.visible = false;
	healthBarBG.visible = false;
	healthBar.visible = false;
	self.hasBeenDamaged = false; // Track if enemy has taken damage
	// Initialize walking animation variables
	self.walkAnimationPhase = Math.random() * Math.PI * 2; // Random starting phase for each enemy
	self.walkAnimationSpeed = 0.12; // Animation speed (slower than normal)
	self.walkBobAmount = 2; // How much to bob up and down (smaller than normal)
	self.lastWalkingState = false;
	self.isCurrentlyMakingSound = false; // Flag to limit footstep sounds
	self.update = function () {
		// Clean up targeting arrays periodically
		if (LK.ticks % 900 === 0) {
			// Every 15 seconds
			if (self.bulletsTargetingThis) {
				self.bulletsTargetingThis = self.bulletsTargetingThis.filter(function (bullet) {
					return bullet && bullet.parent && bullet.targetEnemy === self;
				});
			}
		}
		// Track last health for damage animation
		if (self.lastHealth === undefined) {
			self.lastHealth = self.health;
		}
		// Check if enemy took damage this frame
		if (self.lastHealth > self.health) {
			// Show health bar when enemy takes damage for the first time
			if (!self.hasBeenDamaged) {
				self.hasBeenDamaged = true;
				healthBarOutline.visible = true;
				healthBarBG.visible = true;
				healthBar.visible = true;
			}
		}
		// Hide health bar when enemy is at full health
		if (self.health >= self.maxHealth && self.hasBeenDamaged) {
			healthBarOutline.visible = false;
			healthBarBG.visible = false;
			healthBar.visible = false;
		} else if (self.hasBeenDamaged && self.health < self.maxHealth) {
			// Keep health bar visible when damaged but not at full health
			healthBarOutline.visible = true;
			healthBarBG.visible = true;
			healthBar.visible = true;
		}
		// Update last health
		self.lastHealth = self.health;
		if (self.health <= 0) {
			self.health = 0;
			self.healthBar.width = 0;
		} else {
			// Ensure health bar is properly updated when health > 0
			self.healthBar.width = Math.max(1, self.health / self.maxHealth * 70); // Ensure minimum width of 1
		}
		// Additional validation to ensure fındık enemy health is managed correctly
		if (self.health > 0 && self.health < self.maxHealth) {
			// Force health bar to be visible and correctly sized
			self.healthBar.visible = true;
			self.healthBar.width = Math.max(1, self.health / self.maxHealth * 70); // Ensure minimum width of 1
		}
		// Critical fix: Ensure Fındık enemy is always alive - they are immortal
		// Force health to always be at maximum to prevent any removal
		self.health = self.maxHealth;
		// Ensure health bar reflects full health
		if (self.healthBar) {
			self.healthBar.width = 70; // Always show full health bar
		}
		// Never allow Fındık to have 0 or negative health
		if (self.health <= 0) {
			self.health = self.maxHealth;
		}
		// CRITICAL: Override any external health modifications
		// This ensures no bullet or other system can reduce Fındık health
		Object.defineProperty(self, 'health', {
			get: function get() {
				return self.maxHealth;
			},
			set: function set(value) {
				// Always maintain maximum health - ignore any attempts to reduce it
				self._actualHealth = self.maxHealth;
			},
			configurable: true
		});
		// Handle slow and poison effects like other enemies
		if (self.slowed) {
			self.slowDuration--;
			if (self.slowDuration <= 0) {
				self.speed = self.originalSpeed;
				self.slowed = false;
				findikGraphics.tint = 0xFFFFFF; // Reset tint 
			}
		}
		if (self.poisoned) {
			// 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;
				if (!self.slowed) {
					findikGraphics.tint = 0xFFFFFF; // Reset tint 
				}
			}
		}
		// Set tint based on effect status
		if (self.poisoned && self.slowed) {
			findikGraphics.tint = 0xFF0000;
		} else if (self.slowed) {
			findikGraphics.tint = 0xFF0000;
		} else {
			findikGraphics.tint = 0xFFFFFF;
		}
		// Walking animation logic
		var isOnScreen = self.currentCellY >= -1;
		var isCurrentlyWalking = isOnScreen && (self.currentTarget && (self.currentTarget.x !== self.currentCellX || self.currentTarget.y !== self.currentCellY) || self.currentCellY < 4);
		// Update walking animation if enemy is moving and on screen
		if (isCurrentlyWalking) {
			// Advance animation phase based on actual movement speed
			var speedMultiplier = self.speed * 100;
			self.walkAnimationPhase += self.walkAnimationSpeed * speedMultiplier;
			// Create realistic walking motion
			var primaryBob = Math.sin(self.walkAnimationPhase) * self.walkBobAmount;
			var secondaryBob = Math.sin(self.walkAnimationPhase * 2) * (self.walkBobAmount * 0.3);
			var combinedBobOffset = primaryBob + secondaryBob;
			// Add subtle horizontal sway for more natural movement
			var horizontalSway = Math.sin(self.walkAnimationPhase * 0.5) * (self.walkBobAmount * 0.2);
			// Fındık enemies don't have feet to animate
			// Apply animation to enemy body
			var targetY = combinedBobOffset;
			var targetX = horizontalSway;
			if (!self.animatingMovement) {
				self.animatingMovement = true;
				tween(findikGraphics, {
					y: targetY,
					x: targetX
				}, {
					duration: 80,
					easing: tween.easeOut,
					onFinish: function onFinish() {
						self.animatingMovement = false;
					}
				});
			}
			// Play footstep sound for walking animation
			var walkCycle = Math.floor(self.walkAnimationPhase / (Math.PI / 2)) % 4;
			var lastWalkCycle = Math.floor((self.walkAnimationPhase - self.walkAnimationSpeed * speedMultiplier) / (Math.PI / 2)) % 4;
			// Play walking sound with reduced frequency
			if (walkCycle !== lastWalkCycle && walkCycle % 2 === 0 && !self.isCurrentlyMakingSound) {
				// Limit walking sounds based on enemy count
				var enemyCount = enemies ? enemies.length : 0;
				var shouldPlaySound = enemyCount <= 10 ? true : Math.random() < 0.2; // 20% chance for large groups
				if (shouldPlaySound) {
					self.isCurrentlyMakingSound = true;
					LK.getSound('walking').play();
					// Reset sound flag after delay
					tween({}, {}, {
						duration: 400,
						onFinish: function onFinish() {
							self.isCurrentlyMakingSound = false;
						}
					});
				}
			}
		} else {
			// Return to resting position when not walking
			if (findikGraphics.y !== 0 || findikGraphics.x !== 0) {
				tween.stop(findikGraphics, {
					y: true,
					x: true
				});
				tween(findikGraphics, {
					y: 0,
					x: 0
				}, {
					duration: 200,
					easing: tween.easeOut
				});
				self.animatingMovement = false;
			}
			// Fındık enemies don't have feet to reset
		}
		// Update health bar position
		healthBarOutline.y = healthBarBG.y = healthBar.y = -findikGraphics.height / 2 - 10;
	};
	return self;
});
// BossEnemy class removed - using regular enemies with health multipliers instead
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 || enemy.type === 'vex') {
				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;
			}
		}
		// Cache the successful pathfinding result
		pathfindingCache = {
			maxScore: maxScore,
			pathId: pathId,
			type: requestType
		};
		for (var i = 0; i < self.cells.length; i++) {
			pathfindingCache[i] = [];
			for (var j = 0; j < self.cells[i].length; j++) {
				var cell = self.cells[i][j];
				pathfindingCache[i][j] = {
					score: cell.score,
					pathId: cell.pathId,
					targets: cell.targets.slice() // Copy array
				};
			}
		}
		lastPathfindTime = LK.ticks;
		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) {
			// Fındık enemies should be removed when reaching goal
			return true;
		}
		// Update spatial grid when an enemy reaches the goal
		spatialGrid.clear();
		for (var i = 0; i < enemies.length; i++) {
			spatialGrid.addEnemy(enemies[i]);
		}
		// 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) {
			// Enhanced walking animation for pre-entry movement (disabled for flying enemies)
			if (!enemy.isFlying) {
				var speedMultiplier = enemy.speed * 100;
				enemy.walkAnimationPhase += enemy.walkAnimationSpeed * speedMultiplier;
				// Create more realistic pre-entry walking motion
				var primaryBob = Math.sin(enemy.walkAnimationPhase) * enemy.walkBobAmount;
				var secondaryBob = Math.sin(enemy.walkAnimationPhase * 2) * (enemy.walkBobAmount * 0.2);
				var bobOffset = primaryBob + secondaryBob;
				// Add slight horizontal movement for pre-entry
				var horizontalSway = Math.sin(enemy.walkAnimationPhase * 0.7) * (enemy.walkBobAmount * 0.15);
				if (enemy.children[0]) {
					// Apply different animation styles based on enemy type during pre-entry
					var animationIntensity = 1;
					switch (enemy.type) {
						case 'fast':
							animationIntensity = 1.4;
							break;
						case 'swarm':
							animationIntensity = 1.2;
							break;
					}
					if (enemy.isBoss) {
						animationIntensity *= 0.8;
						bobOffset *= 1.1;
					}
					// Smooth animation application
					var targetY = bobOffset * animationIntensity;
					var targetX = horizontalSway * animationIntensity;
					if (!enemy.preEntryAnimating) {
						enemy.preEntryAnimating = true;
						tween(enemy.children[0], {
							y: targetY,
							x: targetX
						}, {
							duration: 60,
							easing: tween.easeOut,
							onFinish: function onFinish() {
								enemy.preEntryAnimating = false;
							}
						});
					}
				}
				// Play footstep sound for pre-entry movement
				var walkCycle = Math.floor(enemy.walkAnimationPhase / (Math.PI / 2)) % 4;
				var lastWalkCycle = Math.floor((enemy.walkAnimationPhase - enemy.walkAnimationSpeed) / (Math.PI / 2)) % 4;
			}
			// 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 smoothly
			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 smoothly
			if (enemy.currentCellY >= 4) {
				// Smoothly update cell coordinates to prevent teleporting
				var newCellX = Math.round(enemy.currentCellX);
				var newCellY = Math.round(enemy.currentCellY);
				// Always keep cellX and cellY synchronized with currentCellX and currentCellY
				enemy.cellX = newCellX;
				enemy.cellY = newCellY;
				// Scale up vex enemy feet to proper size when entering game area
				if (enemy.type === 'vex' && enemy.leftFoot && enemy.rightFoot) {
					// Animate feet to proper size
					tween(enemy.leftFoot.children[0], {
						width: 24,
						height: 18
					}, {
						duration: 300,
						easing: tween.easeOut
					});
					tween(enemy.rightFoot.children[0], {
						width: 24,
						height: 18
					}, {
						duration: 300,
						easing: tween.easeOut
					});
				}
				// Play goddayfordie sound when normal enemies first enter the screen
				if (enemy.type === 'normal' && !godDayForDieSoundPlayed) {
					godDayForDieSoundPlayed = true;
					LK.getSound('goddayfordie').play();
				}
				// Play guys sound when vex enemies first enter the screen
				if (enemy.type === 'vex' && !window.guysSoundPlayed) {
					window.guysSoundPlayed = true;
					LK.getSound('guys').play();
				}
				// Play wu sound when rat enemies first enter the screen
				if (enemy.type === 'rat' && !window.wuSoundPlayed) {
					window.wuSoundPlayed = true;
					LK.getSound('wu').play();
					// Play bolt sound 3 seconds after wu sound
					tween({}, {}, {
						duration: 3000,
						onFinish: function onFinish() {
							LK.getSound('bolt').play();
							// Play hamburger sound 10 seconds after bolt sound
							tween({}, {}, {
								duration: 10000,
								onFinish: function onFinish() {
									LK.getSound('hamburger').play();
									// Play kola sound 10 seconds after hamburger sound (reduced from 3 to 10 seconds total delay)
									tween({}, {}, {
										duration: 10000,
										onFinish: function onFinish() {
											console.log("Playing kola sound");
											LK.getSound('kola').play();
											// Play hungry sound 10 seconds after kola sound
											tween({}, {}, {
												duration: 10000,
												onFinish: function onFinish() {
													console.log("Playing hungry sound");
													LK.getSound('hungry').play();
												}
											});
										}
									});
								}
							});
						}
					});
				}
				// Play dog sound when fex enemies first enter the screen
				if (enemy.type === 'fex' && !window.dogSoundPlayed) {
					window.dogSoundPlayed = true;
					LK.getSound('dog').play();
					// Spawn Fındık enemy 22 seconds after dog sound
					tween({}, {}, {
						duration: 22000,
						// 22 seconds
						onFinish: function onFinish() {
							if (currentWave === 4) {
								var findikEnemy = new FindikEnemy();
								enemyLayerBottom.addChild(findikEnemy);
								findikEnemy.cellX = 14; // Spawn position
								findikEnemy.cellY = 5;
								findikEnemy.currentCellX = 14;
								findikEnemy.currentCellY = -1 - Math.random() * 5;
								findikEnemy.waveNumber = currentWave;
								enemies.push(findikEnemy);
								// Fındık enemy spawning is now independent - no longer depends on fex enemy presence
								// Fındık enemies spawn based on their own timer and conditions
								// Play 'hav' sound 5 seconds after Fındık enemy spawns
								tween({}, {}, {
									duration: 5000,
									// 5 second delay
									onFinish: function onFinish() {
										LK.getSound('hav').play();
										// Speed up all fex enemies after 'hav' sound
										for (var i = 0; i < enemies.length; i++) {
											var enemy = enemies[i];
											if (enemy.type === 'fex' && enemy.parent) {
												// Use tween to smoothly increase fex enemy speed
												tween(enemy, {
													speed: enemy.speed * 1.5 // Increase speed by 50%
												}, {
													duration: 1000,
													// 1 second transition
													easing: tween.easeOut
												});
											}
										}
										// Play 'ner' sound 1 second after 'hav' sound
										tween({}, {}, {
											duration: 1000,
											// 1 second delay
											onFinish: function onFinish() {
												LK.getSound('ner').play();
												// Play 'hv2' sound after 'ner' sound
												tween({}, {}, {
													duration: 3000,
													// 3 second delay after ner sound
													onFinish: function onFinish() {
														LK.getSound('hv2').play();
														// Play 'hv3' sound 1 second after 'hv2' sound
														tween({}, {}, {
															duration: 1000,
															// 1 second delay after hv2 sound
															onFinish: function onFinish() {
																LK.getSound('hv3').play();
																// Play 'hv3' sound again after 2 seconds
																tween({}, {}, {
																	duration: 2000,
																	// 2 second interval
																	onFinish: function onFinish() {
																		LK.getSound('hv3').play();
																		// Play 'hv4' sound 3 seconds after second hv3 sound
																		tween({}, {}, {
																			duration: 3000,
																			// 3 second delay after second hv3 sound
																			onFinish: function onFinish() {
																				LK.getSound('hv4').play();
																				// Play 'hlp' sound 3 seconds after hv4 sound
																				tween({}, {}, {
																					duration: 3000,
																					// 3 second delay after hv4 sound
																					onFinish: function onFinish() {
																						LK.getSound('hlp').play();
																					}
																				});
																			}
																		});
																	}
																});
															}
														});
													}
												});
											}
										});
									}
								});
							}
						}
					});
				}
				// Play fast enemy sounds when fast enemies first enter the screen
				if (enemy.type === 'fast' && !fastEnemySoundPlayed) {
					fastEnemySoundPlayed = true;
					// Play first sound when enemy enters screen
					LK.getSound('fast_enemy_sound').play();
					// Play second sound after a 5 second delay
					tween({}, {}, {
						duration: 5000,
						// 5 second delay between fast enemy sounds
						onFinish: function onFinish() {
							LK.getSound('for_the_fallen').play();
							// Spawn 1 rat enemy when for_the_fallen sound starts playing - ONLY in Wave 5
							if (currentWave === 5) {
								var ratEnemy = new Enemy('rat');
								// Add rat enemy to the appropriate layer
								if (ratEnemy.isFlying) {
									enemyLayerTop.addChild(ratEnemy);
								} else {
									enemyLayerBottom.addChild(ratEnemy);
								}
								// Set rat enemy health for Wave 5 - reduced for performance
								ratEnemy.maxHealth = 600;
								ratEnemy.health = ratEnemy.maxHealth;
								// Rat enemy always spawns from gridX14
								var spawnX = 14; // Always spawn from gridX14
								var spawnY = -1 - Math.random() * 5; // Random distance above the grid
								ratEnemy.cellX = spawnX;
								ratEnemy.cellY = 5; // Position after entry
								ratEnemy.currentCellX = spawnX;
								ratEnemy.currentCellY = spawnY;
								ratEnemy.waveNumber = currentWave;
								enemies.push(ratEnemy);
							}
						}
					});
				}
				// Play xr sound when flying enemies from Wave 4 first enter the screen
				if (enemy.type === 'flying' && enemy.waveNumber === 4 && !window.xrSoundPlayed) {
					window.xrSoundPlayed = true;
					LK.getSound('xr').play();
					// Play yarış sound after xr sound finishes - increased delay to ensure xr sound completes
					tween({}, {}, {
						duration: 4000,
						// Wait longer for xr sound to finish completely
						onFinish: function onFinish() {
							LK.getSound('yar').play();
							// Play upit sound after yar sound finishes
							tween({}, {}, {
								duration: 5000,
								// Wait longer for yar sound to finish completely
								onFinish: function onFinish() {
									LK.getSound('upit').play();
									// Play water sound 3 seconds after upit sound finishes
									tween({}, {}, {
										duration: 4000,
										// Wait for upit sound to finish + 3 second delay
										onFinish: function onFinish() {
											LK.getSound('water').play();
											// Play funny sound 3 seconds after water sound finishes
											tween({}, {}, {
												duration: 5000,
												// Wait for water sound to finish + 3 second delay
												onFinish: function onFinish() {
													LK.getSound('funny').play();
													// Play z sound 5 seconds after funny sound finishes
													tween({}, {}, {
														duration: 5000,
														// Wait 5 seconds after funny sound
														onFinish: function onFinish() {
															LK.getSound('z').play();
															// Spawn fex enemy after z sound finishes
															tween({}, {}, {
																duration: 2000,
																// Wait 2 seconds for z sound to finish
																onFinish: function onFinish() {
																	// Only spawn fex enemy in wave 4
																	if (currentWave === 4) {
																		var fexEnemy = new FexEnemy();
																		// Add fex enemy to the appropriate layer (walking enemy)
																		enemyLayerBottom.addChild(fexEnemy);
																		// Set fex enemy health for Wave 4
																		fexEnemy.maxHealth = 1000;
																		fexEnemy.health = fexEnemy.maxHealth;
																		// Fex enemy always spawns from gridx14
																		var spawnX = 14; // Always spawn from gridx14
																		var spawnY = -1 - Math.random() * 5; // Random distance above the grid
																		fexEnemy.cellX = spawnX;
																		fexEnemy.cellY = 5; // Position after entry
																		fexEnemy.currentCellX = spawnX;
																		fexEnemy.currentCellY = spawnY;
																		fexEnemy.waveNumber = currentWave;
																		enemies.push(fexEnemy);
																	}
																	// Play sm sound 3 seconds after fex enemy spawns (delayed by 1 second more)
																	tween({}, {}, {
																		duration: 3000,
																		onFinish: function onFinish() {
																			LK.getSound('sm').play();
																		}
																	});
																}
															});
														}
													});
												}
											});
										}
									});
								}
							});
						}
					});
				}
				// Play we sound only once when boss enemy from Wave 7 first appears on screen
				if (enemy.waveNumber === 7 && enemy.isBoss && !weSoundPlayed) {
					weSoundPlayed = true;
					LK.getSound('we').play();
					// Play ek sound after we sound finishes
					tween({}, {}, {
						duration: 2000,
						// Adjust timing based on 'we' sound duration
						onFinish: function onFinish() {
							LK.getSound('ek').play();
							// Play tw sound after ek sound finishes
							tween({}, {}, {
								duration: 2000,
								// Adjust timing based on 'ek' sound duration
								onFinish: function onFinish() {
									LK.getSound('tw').play();
									// Play sh sound after tw sound finishes
									tween({}, {}, {
										duration: 15000,
										// Adjust timing based on 'tw' sound duration
										onFinish: function onFinish() {
											LK.getSound('sh').play();
										}
									});
								}
							});
						}
					});
				}
				// df sound is now played when Wave 8 starts, not when enemies enter screen
			}
			return false;
		}
		// Handle vex enemy - move to y13, then move right 3 cells, then stop
		if (enemy.type === 'vex') {
			// Initialize vex movement phase if not set
			if (!enemy.vexPhase) {
				enemy.vexPhase = 'movingDown';
				enemy.targetX = enemy.currentCellX + 2; // Target position 2 cells to the right
			}
			if (enemy.vexPhase === 'movingDown') {
				// Check if vex enemy has reached y13
				if (enemy.currentCellY >= 13) {
					// Switch to moving right phase
					enemy.vexPhase = 'movingRight';
					enemy.currentCellY = 13; // Ensure we're exactly at y13
					// Play sound 'n' when vex enemy turns right and track when it finishes
					LK.getSound('n').play();
					// Use tween to track when 'n' sound finishes (assume it's about 2-3 seconds)
					tween({}, {}, {
						duration: 2500,
						// Estimated duration of 'n' sound in milliseconds
						onFinish: function onFinish() {
							nSoundFinished = true; // Mark that 'n' sound has finished
						}
					});
					// Stop any ongoing rotation animations before asset switching
					if (enemy.children[0]) {
						tween.stop(enemy.children[0], {
							rotation: true
						});
					}
					// Simplified asset switching - remove the problematic rotation logic
					if (enemy.children[0] && enemy.children[0].parent) {
						enemy.removeChild(enemy.children[0]);
						var vxGraphics = enemy.attachAsset('vx', {
							anchorX: 0.5,
							anchorY: 0.5,
							scaleX: 1.25,
							scaleY: 1.25
						});
						vxGraphics.rotation = 0; // Face right immediately
						vxGraphics.targetRotation = 0; // Set target rotation to prevent further rotation
					}
				} else {
					// Continue moving down to y13
					enemy.currentCellY += enemy.speed;
					// Main walking animation system will handle vex animation during movingDown phase
				}
				// Rotate enemy graphic to face downward while moving
				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
						});
						var currentRotation = enemy.children[0].rotation;
						var angleDiff = angle - currentRotation;
						while (angleDiff > Math.PI) {
							angleDiff -= Math.PI * 2;
						}
						while (angleDiff < -Math.PI) {
							angleDiff += Math.PI * 2;
						}
						enemy.children[0].targetRotation = angle;
						tween(enemy.children[0], {
							rotation: currentRotation + angleDiff
						}, {
							duration: 250,
							easing: tween.easeOut
						});
					}
				}
			} else if (enemy.vexPhase === 'movingRight') {
				// Check if vex enemy has moved 3 cells to the right
				if (enemy.currentCellX >= enemy.targetX) {
					// Stop moving - we've reached the target position
					enemy.vexPhase = 'waiting';
					enemy.currentCellX = enemy.targetX; // Ensure exact position
					enemy.waitTimer = 0; // Initialize wait timer
					// CRITICAL: Stop main walking animation when turning right
					if (enemy.leftFoot && enemy.rightFoot) {
						// Stop any ongoing foot animations
						tween.stop(enemy.leftFoot, {
							scaleX: true,
							scaleY: true,
							x: true,
							y: true
						});
						tween.stop(enemy.rightFoot, {
							scaleX: true,
							scaleY: true,
							x: true,
							y: true
						});
						// Reset animation flags
						enemy.leftFoot.isAnimating = false;
						enemy.leftFoot.isRightScaling = false;
						enemy.rightFoot.isAnimating = false;
						enemy.rightFoot.isRightScaling = false;
						// Keep feet at static positions
						enemy.leftFoot.scaleX = 1;
						enemy.leftFoot.scaleY = 1;
						enemy.rightFoot.scaleX = 1;
						enemy.rightFoot.scaleY = 1;
					}
					// Play 'wc' sound when starting to wait, but only if 'n' sound has finished
					if (nSoundFinished) {
						// Add additional delay even when 'n' sound is marked as finished to ensure proper timing
						tween({}, {}, {
							duration: 2000,
							// 2 second additional delay (1 second more than before)
							onFinish: function onFinish() {
								LK.getSound('wc').play();
							}
						});
					} else {
						// Wait for 'n' sound to finish before playing 'wc'
						var _checkNSoundFinished = function checkNSoundFinished() {
							if (nSoundFinished) {
								// Add delay to ensure 'n' sound has completely finished
								tween({}, {}, {
									duration: 2500,
									// 2.5 second delay after 'n' finishes (1 second more than before)
									onFinish: function onFinish() {
										LK.getSound('wc').play();
									}
								});
							} else {
								// Check again in 100ms
								tween({}, {}, {
									duration: 100,
									onFinish: _checkNSoundFinished
								});
							}
						};
						_checkNSoundFinished();
					}
				} else {
					// Continue moving right
					enemy.currentCellX += enemy.speed;
					// Ensure vex enemy stays facing right during movement
					if (enemy.children[0]) {
						enemy.children[0].rotation = 0;
						enemy.children[0].targetRotation = 0;
					}
					// DO NOT change foot positions during turning movement - keep feet stable
				}
			} else if (enemy.vexPhase === 'waiting') {
				// Wait for 8 seconds (480 frames at 60 FPS)
				if (!enemy.waitTimer) enemy.waitTimer = 0;
				enemy.waitTimer++;
				if (enemy.waitTimer >= 480) {
					// CRITICAL: Preserve feet during asset switching
					var leftFootBackup = null;
					var rightFootBackup = null;
					// Store current foot state before asset switch
					if (enemy.leftFoot && enemy.leftFoot.parent) {
						leftFootBackup = {
							x: enemy.leftFoot.x,
							y: enemy.leftFoot.y,
							scaleX: enemy.leftFoot.scaleX,
							scaleY: enemy.leftFoot.scaleY,
							rotation: enemy.leftFoot.rotation,
							visible: enemy.leftFoot.visible,
							alpha: enemy.leftFoot.alpha
						};
					}
					if (enemy.rightFoot && enemy.rightFoot.parent) {
						rightFootBackup = {
							x: enemy.rightFoot.x,
							y: enemy.rightFoot.y,
							scaleX: enemy.rightFoot.scaleX,
							scaleY: enemy.rightFoot.scaleY,
							rotation: enemy.rightFoot.rotation,
							visible: enemy.rightFoot.visible,
							alpha: enemy.rightFoot.alpha
						};
					}
					// Stop any ongoing rotation animations before asset switching
					if (enemy.children[0]) {
						tween.stop(enemy.children[0], {
							rotation: true
						});
					}
					// Switch to vx asset
					if (enemy.children[0] && enemy.children[0].parent) {
						enemy.removeChild(enemy.children[0]);
					}
					var vxGraphics = enemy.attachAsset('vx', {
						anchorX: 0.5,
						anchorY: 0.5,
						scaleX: 1.25,
						scaleY: 1.25
					});
					// No rotation animation - vx asset appears without rotation
					vxGraphics.rotation = 0; // Face right immediately without animation
					vxGraphics.targetRotation = 0; // Set target rotation to prevent further rotation
					// CRITICAL: Restore feet after asset switch
					if (leftFootBackup && enemy.leftFoot) {
						enemy.leftFoot.x = leftFootBackup.x;
						enemy.leftFoot.y = leftFootBackup.y;
						enemy.leftFoot.scaleX = leftFootBackup.scaleX;
						enemy.leftFoot.scaleY = leftFootBackup.scaleY;
						enemy.leftFoot.rotation = leftFootBackup.rotation;
						enemy.leftFoot.visible = true; // Force visible
						enemy.leftFoot.alpha = 1; // Force full opacity
						// Ensure left foot is properly attached
						if (!enemy.leftFoot.parent) {
							enemy.addChild(enemy.leftFoot);
						}
					}
					if (rightFootBackup && enemy.rightFoot) {
						enemy.rightFoot.x = rightFootBackup.x;
						enemy.rightFoot.y = rightFootBackup.y;
						enemy.rightFoot.scaleX = rightFootBackup.scaleX;
						enemy.rightFoot.scaleY = rightFootBackup.scaleY;
						enemy.rightFoot.rotation = rightFootBackup.rotation;
						enemy.rightFoot.visible = true; // Force visible
						enemy.rightFoot.alpha = 1; // Force full opacity
						// Ensure right foot is properly attached
						if (!enemy.rightFoot.parent) {
							enemy.addChild(enemy.rightFoot);
						}
					}
					// Emergency foot recreation if backup failed
					if (!enemy.leftFoot || !enemy.leftFoot.parent) {
						enemy.leftFoot = new Container();
						var leftFootGraphics = enemy.leftFoot.attachAsset('vxFeet', {
							anchorX: 0.5,
							anchorY: 0.5
						});
						leftFootGraphics.width = 24;
						leftFootGraphics.height = 18;
						leftFootGraphics.tint = 0x000000;
						enemy.leftFoot.x = -18;
						enemy.leftFoot.y = 35;
						enemy.leftFoot.visible = true;
						enemy.leftFoot.alpha = 1;
						enemy.addChild(enemy.leftFoot);
					}
					if (!enemy.rightFoot || !enemy.rightFoot.parent) {
						enemy.rightFoot = new Container();
						var rightFootGraphics = enemy.rightFoot.attachAsset('vxFeet', {
							anchorX: 0.5,
							anchorY: 0.5
						});
						rightFootGraphics.width = 24;
						rightFootGraphics.height = 18;
						rightFootGraphics.tint = 0x000000;
						enemy.rightFoot.x = 18;
						enemy.rightFoot.y = 35;
						enemy.rightFoot.visible = true;
						enemy.rightFoot.alpha = 1;
						enemy.addChild(enemy.rightFoot);
					}
					// Start returning to spawn area
					enemy.vexPhase = 'returningToSpawn';
					enemy.returnTargetX = 13; // Return to gridX13 column
					enemy.returnTargetY = -3; // Return above the spawn area
					// Stop vx swaying animation when leaving waiting phase
					if (enemy.vxSwayAnimation) {
						enemy.vxSwayAnimation = false;
						enemy.vxSwayActive = false;
						// Reset vx visual position to center smoothly
						if (enemy.children[0]) {
							tween(enemy.children[0], {
								x: 0,
								y: 0
							}, {
								duration: 300,
								easing: tween.easeOut
							});
						}
					}
				}
			} else if (enemy.vexPhase === 'returningToSpawn') {
				// Initialize safety timer if not set
				if (!enemy.returningSafetyTimer) {
					enemy.returningSafetyTimer = 0;
				}
				enemy.returningSafetyTimer++;
				// Safety timeout: force delete after 4 seconds (400 frames at 60fps)
				if (enemy.returningSafetyTimer > 400) {
					// Stop vex swaying animation before deletion
					if (enemy.vxSwayAnimation) {
						enemy.vxSwayAnimation = false;
						enemy.vxSwayActive = false;
						// Clear any ongoing tweens on the vex graphics
						if (enemy.children[0]) {
							tween.stop(enemy.children[0], {
								x: true,
								y: true,
								rotation: true
							});
						}
					}
					// Force delete vex enemy after timeout
					if (enemy.parent) {
						if (enemy.isFlying) {
							enemyLayerTop.removeChild(enemy);
						} else {
							enemyLayerBottom.removeChild(enemy);
						}
					}
					var enemyIndex = enemies.indexOf(enemy);
					if (enemyIndex !== -1) {
						enemies.splice(enemyIndex, 1);
					}
					// Once vex enemy exits, allow wave 2 to start
					if (currentWave === 1) {
						// Automatically start wave 2 after vex enemy exits
						currentWave = 2;
						waveTimer = 0;
						waveInProgress = true;
						waveSpawned = false;
					}
					return true; // Return true to indicate enemy reached goal (exit condition)
				}
				// Move back to spawn area first
				var dx = enemy.returnTargetX - enemy.currentCellX;
				var dy = enemy.returnTargetY - enemy.currentCellY;
				var distance = Math.sqrt(dx * dx + dy * dy);
				// Improved deletion conditions - delete vex enemy when it's completely off-screen
				if (enemy.currentCellY <= -3 || enemy.y <= -100) {
					// Stop vex swaying animation before deletion
					if (enemy.vxSwayAnimation) {
						enemy.vxSwayAnimation = false;
						enemy.vxSwayActive = false;
						// Clear any ongoing tweens on the vex graphics
						if (enemy.children[0]) {
							tween.stop(enemy.children[0], {
								x: true,
								y: true,
								rotation: true
							});
						}
					}
					// Delete vex enemy immediately when it's completely off-screen
					if (enemy.parent) {
						if (enemy.isFlying) {
							enemyLayerTop.removeChild(enemy);
						} else {
							enemyLayerBottom.removeChild(enemy);
						}
					}
					var enemyIndex = enemies.indexOf(enemy);
					if (enemyIndex !== -1) {
						enemies.splice(enemyIndex, 1);
					}
					// Stop vex swaying animation when enemy exits
					if (enemy.vxSwayAnimation) {
						enemy.vxSwayAnimation = false;
						enemy.vxSwayActive = false;
						// Clear any ongoing tweens on the vex graphics
						if (enemy.children[0]) {
							tween.stop(enemy.children[0], {
								x: true,
								y: true,
								rotation: true
							});
						}
					}
					// Once vex enemy exits, allow wave 2 to start
					if (currentWave === 1) {
						// Automatically start wave 2 after vex enemy exits
						currentWave = 2;
						waveTimer = 0;
						waveInProgress = true;
						waveSpawned = false;
					}
					return true; // Return true to indicate enemy reached goal (exit condition)
				} else {
					// Move toward spawn area
					var angle = Math.atan2(dy, dx);
					enemy.currentCellX += Math.cos(angle) * enemy.speed;
					enemy.currentCellY += Math.sin(angle) * enemy.speed;
					// Set rotation immediately without animation to prevent tilting
					if (enemy.children[0]) {
						// Stop any ongoing rotation animations
						tween.stop(enemy.children[0], {
							rotation: true
						});
						// Set rotation directly for stable facing direction
						enemy.children[0].rotation = angle;
						enemy.children[0].targetRotation = angle;
						// Ensure sprite stays upright when not actively moving
						if (Math.abs(angle) < 0.1) {
							enemy.children[0].rotation = 0;
							enemy.children[0].targetRotation = 0;
						}
					}
				}
			} else if (enemy.vexPhase === 'exitingFromSpawn') {
				// Move upward to exit off the top of the screen
				enemy.currentCellY -= enemy.speed;
				// Rotate enemy to face upward
				var angle = -Math.PI / 2; // Face upward
				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
						});
						var currentRotation = enemy.children[0].rotation;
						var angleDiff = angle - currentRotation;
						while (angleDiff > Math.PI) {
							angleDiff -= Math.PI * 2;
						}
						while (angleDiff < -Math.PI) {
							angleDiff += Math.PI * 2;
						}
						enemy.children[0].targetRotation = angle;
						tween(enemy.children[0], {
							rotation: currentRotation + angleDiff
						}, {
							duration: 250,
							easing: tween.easeOut
						});
					}
				}
				// Check if enemy has moved far enough off screen to be removed
				if (enemy.currentCellY < -5) {
					// Stop vex swaying animation before deletion
					if (enemy.vxSwayAnimation) {
						enemy.vxSwayAnimation = false;
						enemy.vxSwayActive = false;
						// Clear any ongoing tweens on the vex graphics
						if (enemy.children[0]) {
							tween.stop(enemy.children[0], {
								x: true,
								y: true,
								rotation: true
							});
						}
					}
					// Remove vex enemy completely off screen
					if (enemy.parent) {
						if (enemy.isFlying) {
							enemyLayerTop.removeChild(enemy);
						} else {
							enemyLayerBottom.removeChild(enemy);
						}
					}
					var enemyIndex = enemies.indexOf(enemy);
					if (enemyIndex !== -1) {
						enemies.splice(enemyIndex, 1);
					}
					// Once vex enemy exits, allow wave 2 to start
					if (currentWave === 1) {
						// Automatically start wave 2 after vex enemy exits
						currentWave = 2;
						waveTimer = 0;
						waveInProgress = true;
						waveSpawned = false;
					}
					return true; // Return true to indicate enemy reached goal (exit condition)
				}
				// Main walking animation system will handle vex animation during all movement phases
			} else if (enemy.vexPhase === 'waiting' || enemy.vexPhase === 'returningToSpawn') {
				// Main walking animation system will handle vex animation during all movement phases
			}
			// If stopped, just maintain position (no movement)
			// Update enemy's position
			enemy.cellX = Math.round(enemy.currentCellX);
			enemy.cellY = Math.round(enemy.currentCellY);
			enemy.x = grid.x + enemy.currentCellX * CELL_SIZE;
			enemy.y = grid.y + enemy.currentCellY * CELL_SIZE;
			return false; // Don't use normal pathfinding
		}
		// 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;
			}
			// Flying enemies move without wing-flapping animation - simple smooth movement
			// Flying enemy exhaust animation removed
			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 kırık enemy - move in L-shape: straight down, then straight right to tabela, then return
		if (enemy.type === 'kırık' && enemy.isImmortal) {
			// Initialize kırık phase if not set
			if (!enemy.kırıkPhase) {
				enemy.kırıkPhase = 'movingDown';
				enemy.startX = enemy.currentCellX; // Remember starting position
				enemy.startY = enemy.currentCellY;
			}
			// Calculate tabela position in grid coordinates (where tabela display is positioned)
			var tabelaGridX = (2048 - 360 - 76 - grid.x) / CELL_SIZE;
			var tabelaGridY = (2732 / 2 + 76 - grid.y) / CELL_SIZE;
			if (enemy.kırıkPhase === 'movingDown') {
				// Move straight down like blue enemy until reaching bottom of screen
				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
						});
						var currentRotation = enemy.children[0].rotation;
						var angleDiff = angle - currentRotation;
						while (angleDiff > Math.PI) {
							angleDiff -= Math.PI * 2;
						}
						while (angleDiff < -Math.PI) {
							angleDiff += Math.PI * 2;
						}
						enemy.children[0].targetRotation = angle;
						tween(enemy.children[0], {
							rotation: currentRotation + angleDiff
						}, {
							duration: 250,
							easing: tween.easeOut
						});
					}
				}
				// Check if reached bottom of screen (around where goals are)
				if (enemy.currentCellY >= 34) {
					enemy.kırıkPhase = 'goingToTabela';
				}
			} else if (enemy.kırıkPhase === 'goingToTabela') {
				// Move straight horizontally toward tabela (L-shape movement)
				enemy.currentCellX += enemy.speed; // Move straight right
				// Rotate enemy graphic to face right (0 radians)
				var angle = 0; // Face right
				if (enemy.children[0]) {
					if (enemy.children[0].targetRotation === undefined) {
						enemy.children[0].targetRotation = angle;
						enemy.children[0].rotation = angle;
					} else if (Math.abs(angle - enemy.children[0].targetRotation) > 0.05) {
						tween.stop(enemy.children[0], {
							rotation: true
						});
						var currentRotation = enemy.children[0].rotation;
						var angleDiff = angle - currentRotation;
						while (angleDiff > Math.PI) {
							angleDiff -= Math.PI * 2;
						}
						while (angleDiff < -Math.PI) {
							angleDiff += Math.PI * 2;
						}
						enemy.children[0].targetRotation = angle;
						tween(enemy.children[0], {
							rotation: currentRotation + angleDiff
						}, {
							duration: 250,
							easing: tween.easeOut
						});
					}
				}
				// Check if reached tabela X position
				if (enemy.currentCellX >= tabelaGridX) {
					enemy.kırıkPhase = 'returningToStart';
				}
			} else if (enemy.kırıkPhase === 'returningToStart') {
				// Move straight left back to starting position
				enemy.currentCellX -= enemy.speed; // Move straight left
				// Rotate enemy graphic to face left (PI radians)
				var angle = Math.PI; // Face left
				if (enemy.children[0]) {
					if (enemy.children[0].targetRotation === undefined) {
						enemy.children[0].targetRotation = angle;
						enemy.children[0].rotation = angle;
					} else if (Math.abs(angle - enemy.children[0].targetRotation) > 0.05) {
						tween.stop(enemy.children[0], {
							rotation: true
						});
						var currentRotation = enemy.children[0].rotation;
						var angleDiff = angle - currentRotation;
						while (angleDiff > Math.PI) {
							angleDiff -= Math.PI * 2;
						}
						while (angleDiff < -Math.PI) {
							angleDiff += Math.PI * 2;
						}
						enemy.children[0].targetRotation = angle;
						tween(enemy.children[0], {
							rotation: currentRotation + angleDiff
						}, {
							duration: 250,
							easing: tween.easeOut
						});
					}
				}
				// Check if reached start position
				if (enemy.currentCellX <= enemy.startX) {
					enemy.kırıkPhase = 'movingDown'; // Restart the cycle
				}
			}
			// Update visual position
			enemy.x = grid.x + enemy.currentCellX * CELL_SIZE;
			enemy.y = grid.y + enemy.currentCellY * CELL_SIZE;
			return false; // Don't use normal pathfinding
		}
		// Handle normal pathfinding enemies
		if (!enemy.currentTarget && cell && cell.targets && cell.targets.length > 0) {
			enemy.currentTarget = cell.targets[0];
		}
		if (enemy.currentTarget) {
			// Always use the best target from current cell
			if (cell && cell.targets && cell.targets.length > 0 && cell.score < enemy.currentTarget.score) {
				enemy.currentTarget = cell.targets[0];
			}
			var ox = enemy.currentTarget.x - enemy.currentCellX;
			var oy = enemy.currentTarget.y - enemy.currentCellY;
			var dist = Math.sqrt(ox * ox + oy * oy);
			// Check if enemy is close to reaching the goal (within 2 cells) and play "we are coming for you" sound once (only for normal enemies)
			if (!weAreComingForYouSoundPlayed && cell.score < 20000 && enemy.type === 'normal') {
				// Close to goal
				weAreComingForYouSoundPlayed = true;
				// Play the sound and make enemy disappear after sound finishes
				LK.getSound('wearecomingforyou').play();
				// Use tween to delay enemy disappearing until sound finishes
				tween({}, {}, {
					duration: 2000,
					// Approximate sound duration
					onFinish: function onFinish() {
						// Make the enemy disappear by removing it from the game
						if (enemy.parent) {
							// Shadow cleanup removed as flying enemies no longer use shadows
							// Remove enemy from the appropriate layer
							if (enemy.isFlying) {
								enemyLayerTop.removeChild(enemy);
							} else {
								enemyLayerBottom.removeChild(enemy);
							}
							// Remove from enemies array
							var enemyIndex = enemies.indexOf(enemy);
							if (enemyIndex !== -1) {
								enemies.splice(enemyIndex, 1);
							}
						}
					}
				});
			}
			if (dist < enemy.speed) {
				// Smoothly snap to target position
				enemy.currentCellX = enemy.currentTarget.x;
				enemy.currentCellY = enemy.currentTarget.y;
				enemy.cellX = enemy.currentTarget.x;
				enemy.cellY = enemy.currentTarget.y;
				enemy.currentTarget = null;
				// Immediately get new target from current cell
				var newCell = grid.getCell(enemy.cellX, enemy.cellY);
				if (newCell && newCell.targets && newCell.targets.length > 0) {
					enemy.currentTarget = newCell.targets[0];
				}
				return;
			}
			// Enhanced walking animation for normal pathfinding movement (disabled for flying enemies)
			if (!enemy.isFlying) {
				var speedMultiplier = enemy.speed * 100;
				enemy.walkAnimationPhase += enemy.walkAnimationSpeed * speedMultiplier;
				// Create realistic walking motion with multiple components
				var primaryBob = Math.sin(enemy.walkAnimationPhase) * enemy.walkBobAmount;
				var secondaryBob = Math.sin(enemy.walkAnimationPhase * 2.2) * (enemy.walkBobAmount * 0.25);
				var bobOffset = primaryBob + secondaryBob;
				// Add natural horizontal sway
				var horizontalSway = Math.sin(enemy.walkAnimationPhase * 0.6) * (enemy.walkBobAmount * 0.18);
				if (enemy.children[0]) {
					// Apply type-specific animation characteristics
					var animationIntensity = 1;
					switch (enemy.type) {
						case 'fast':
							animationIntensity = 1.6; // Very energetic
							break;
						case 'immune':
							animationIntensity = 0.75; // More controlled
							break;
						case 'swarm':
							animationIntensity = 1.3; // Quick and jittery
							// Add random jitter for swarm enemies
							bobOffset += (Math.random() - 0.5) * enemy.walkBobAmount * 0.2;
							break;
					}
					if (enemy.isBoss) {
						animationIntensity *= 0.7; // Slower but more imposing
						bobOffset *= 1.3; // More pronounced movement
					}
					// Apply smooth animation transitions
					var targetY = bobOffset * animationIntensity;
					var targetX = horizontalSway * animationIntensity;
					if (!enemy.pathfindingAnimating) {
						enemy.pathfindingAnimating = true;
						tween(enemy.children[0], {
							y: targetY,
							x: targetX
						}, {
							duration: 45,
							easing: tween.easeOut,
							onFinish: function onFinish() {
								enemy.pathfindingAnimating = false;
							}
						});
					}
				}
				// Play footstep sound for normal pathfinding movement
				var walkCycle = Math.floor(enemy.walkAnimationPhase / (Math.PI / 2)) % 4;
				var lastWalkCycle = Math.floor((enemy.walkAnimationPhase - enemy.walkAnimationSpeed) / (Math.PI / 2)) % 4;
			}
			// Calculate movement with proper angle and speed
			var angle = Math.atan2(oy, ox);
			var moveX = Math.cos(angle) * enemy.speed;
			var moveY = Math.sin(angle) * enemy.speed;
			// Apply movement with bounds checking
			enemy.currentCellX += moveX;
			enemy.currentCellY += moveY;
		}
		// Update visual position directly from current cell position for smooth movement
		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('next_wave_bg', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// buttonBackground.tint = 0x0088FF; // Removed to show original image colors
	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 () {
		// Next wave button is removed - always keep it hidden and disabled
		self.enabled = false;
		self.visible = false;
		self.alpha = 0;
	};
	self.down = function () {
		if (!self.enabled) {
			return;
		}
		// Don't allow manual wave progression during black screen (wave 7 completion)
		var isBlackScreenActive = fadeToBlackStarted && bossWaveCompleted && currentWave === 7;
		if (isBlackScreenActive) {
			return; // Block manual wave progression during black screen
		}
		// Check if any vex enemies are still alive to block manual wave progression
		var vexEnemiesAlive = false;
		for (var i = 0; i < enemies.length; i++) {
			if (enemies[i].type === 'vex') {
				vexEnemiesAlive = true;
				break;
			}
		}
		// Block manual progression to wave 2 if vex enemies are still alive
		if (vexEnemiesAlive && currentWave === 1) {
			var notification = game.addChild(new Notification("Defeat all vex enemies before starting next wave!"));
			notification.x = 2048 / 2;
			notification.y = grid.height - 50;
			return;
		}
		if (waveIndicator.gameStarted && currentWave < totalWaves) {
			currentWave++; // Increment to the next wave directly
			waveTimer = 0; // Reset wave timer
			waveInProgress = true;
			waveSpawned = false;
		}
	};
	return self;
});
var Notification = Container.expand(function (message) {
	var self = Container.call(this);
	// Bildirim mesajlarını Türkçeye çevir
	var trMap = {
		"Path is blocked!": "Yol kapalı!",
		"Defeat all vex enemies before starting next wave!": "Sonraki dalgaya geçmeden önce tüm Vex düşmanlarını yok et!",
		"Cannot upgrade towers before game starts!": "Oyun başlamadan kuleler yükseltilemez!",
		"Not enough gold to upgrade!": "Yükseltmek için yeterli altın yok!",
		"Tower is already at max level!": "Kule zaten en yüksek seviyede!",
		"Tower selling is prohibited until wave 8!": "Kule satışı 8. dalgaya kadar yasak!",
		"Tower sold for ": "Kule satıldı: +",
		" gold!": " altın!",
		"tower can only be placed once!": "kule sadece bir kez yerleştirilebilir!",
		"Not enough gold!": "Yeterli altın yok!",
		"Cannot place towers next to each other!": "Kuleler yan yana yerleştirilemez!",
		"Tower would block the path!": "Kule yolu kapatır!",
		"Cannot build: Enemy in the way!": "Yerleştirilemez: Düşman yol üzerinde!",
		"Cannot build here!": "Buraya inşa edilemez!",
		"Place the towers on the green spots.": "Kuleleri yeşil noktalara yerleştir.",
		"Place ": "Yerleştir ",
		" towers before starting! (": " kule yerleştir ve başla! (",
		"place tower": "kule yerleştir",
		"start": "başla",
		"Started!": "Başladı!",
		"Max Level": "Maksimum Seviye",
		"Upgrade: ": "Yükselt: ",
		" gold": " altın",
		"Sell: +": "Sat: +",
		"continue": "devam et",
		"home": "ana menü",
		"And the war is over": "Ve savaş sona erdi",
		"Drones incoming!! Tap and send them to the scrapyard!!!": "Dronlar geliyor! Dokun ve hurdalığa gönder!",
		"Next Wave": "Sonraki Dalga"
	};
	// Otomatik çeviri: bazı mesajlar dinamik olabilir, örn. altın miktarı
	function translate(msg) {
		// Dinamik altın satışı
		if (msg && msg.indexOf("Tower sold for ") === 0 && msg.indexOf(" gold!") > 0) {
			var val = msg.replace("Tower sold for ", "").replace(" gold!", "");
			return "Kule satıldı: +" + val + " altın!";
		}
		// Dinamik kule yerleştirme bildirimi
		if (msg && msg.indexOf("Place ") === 0 && msg.indexOf(" towers before starting!") > 0) {
			var parts = msg.match(/Place (\d+) towers before starting! \((\d+)\/(\d+)\)/);
			if (parts) {
				return "Başlamak için " + parts[1] + " kule yerleştir! (" + parts[2] + "/" + parts[3] + ")";
			}
		}
		// Diğer sabit çeviriler
		if (trMap[msg]) return trMap[msg];
		return msg;
	}
	var notificationGraphics = self.attachAsset('notification', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	var notificationText = new Text2(translate(message), {
		size: 80,
		fill: 0xFFFFFF,
		weight: 800
	});
	notificationText.anchor.set(0.5, 0.5);
	notificationGraphics.width = notificationText.width + 50;
	notificationGraphics.alpha = 0; // Make background transparent
	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 SaykoVisual = Container.expand(function () {
	var self = Container.call(this);
	var saykoGraphics = self.attachAsset('sayko', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.x = 2048 / 2;
	self.y = 2732 / 2;
	// Create story text positioned at top-left with proper wrapping - increased size
	var storyText = new Text2("Yıllar önce, güneş takvimini, su kanallarını, sallanmış masa bacakları için dahiyane kağıt takozunu ve hatta cırt cırtlı bebek bezlerini icat etmekle tanınan dünyanın en gelişmiş uygarlığı Saykolar, savaşlar ve terör yüzünden topraklarını terk etmek zorunda kaldılar. Sığınak arayarak denize açıldılar ve sonunda İstanbul, Türkiye yakınlarında ıssız bir toprak parçasına yerleştiler.\n\nAncak onların gelişi bölgedeki diğer uygarlıklar tarafından hoş karşılanmadı. Daha az gelişmiş olsalar da, bu uygarlıklar sayıca üstündüler ve bu güce dayanarak Saykolara savaş ilan ettiler.", {
		size: 95,
		fill: 0xFFFFFF,
		weight: 600,
		wordWrap: true,
		wordWrapWidth: 1600
	});
	storyText.anchor.set(0, 0);
	storyText.x = -800; // Adjusted position for larger left and right margins
	storyText.y = -1100; // Position slightly lower to avoid blocking pause button
	self.addChild(storyText);
	// Add image asset behind continue text
	var continueBackground = self.attachAsset('continue_bg', {
		anchorX: 1,
		anchorY: 1,
		scaleX: 0.8,
		scaleY: 0.48
	});
	continueBackground.x = 900; // Same position as continue text
	continueBackground.y = 1210; // Moved 10px down from continue text
	continueBackground.tint = 0xFFFFFF; // Full white color for visibility
	continueBackground.alpha = 1.0; // Full opacity for visibility
	// Store reference for external size control
	self.continueBackground = continueBackground;
	// Initially hide the continue background
	continueBackground.alpha = 0;
	// Add "continue" text to bottom right area
	var continueText = new Text2("continue", {
		size: 85,
		// Reduced size from 100 to 85
		fill: 0xFFFFFF,
		weight: 600
	});
	continueText.anchor.set(1, 1); // Anchor to bottom right
	continueText.x = 720; // Moved 25px left from previous position (745 - 25 = 720)
	continueText.y = 1140; // Moved 15px up from previous position
	self.addChild(continueText);
	// Add fade-in animation for the text
	storyText.alpha = 0;
	// Initially hide the continue text
	continueText.alpha = 0;
	tween(storyText, {
		alpha: 1
	}, {
		duration: 1500,
		easing: tween.easeInOut,
		onFinish: function onFinish() {
			// Show continue text 3 seconds after story text finishes appearing
			tween({}, {}, {
				duration: 3000,
				// 3 second delay
				onFinish: function onFinish() {
					tween(continueText, {
						alpha: 1
					}, {
						duration: 1000,
						easing: tween.easeInOut
					});
					// Show continue background at the same time as text
					tween(continueBackground, {
						alpha: 1.0
					}, {
						duration: 1000,
						easing: tween.easeInOut
					});
				}
			});
		}
	});
	// Add methods to control continue background
	self.setContinueBackgroundSize = function (scaleX, scaleY) {
		if (self.continueBackground) {
			self.continueBackground.scaleX = scaleX;
			self.continueBackground.scaleY = scaleY;
		}
	};
	self.setContinueBackgroundAlpha = function (alpha) {
		if (self.continueBackground) {
			self.continueBackground.alpha = alpha;
		}
	};
	self.setContinueBackgroundTint = function (tint) {
		if (self.continueBackground) {
			self.continueBackground.tint = tint;
		}
	};
	self.down = function () {
		self.visible = false;
		// Also hide the story text when sayko is touched
		if (storyText) {
			storyText.visible = false;
		}
		// Also hide the continue text when sayko is touched
		if (continueText) {
			continueText.visible = false;
		}
		// Also hide the continue background when sayko is touched
		if (continueBackground) {
			continueBackground.visible = false;
		}
	};
	return self;
});
var SourceTower = Container.expand(function (towerType) {
	var self = Container.call(this);
	self.towerType = towerType || 'default';
	// Get appropriate asset for this tower type
	var assetId = 'tower_' + self.towerType;
	// Increase size of base for easier touch
	var baseGraphics = self.attachAsset(assetId, {
		anchorX: 0.5,
		anchorY: 0.5,
		scaleX: 1.2,
		scaleY: 1.2
	});
	var towerCost = getTowerCost(self.towerType);
	// Add shadow for tower type label
	var typeLabelShadow = new Text2(self.towerType.charAt(0).toUpperCase() + self.towerType.slice(1), {
		size: 50,
		fill: 0x000000,
		weight: 800
	});
	typeLabelShadow.anchor.set(0.5, 0.5);
	typeLabelShadow.x = 4;
	typeLabelShadow.y = -20 + 4;
	self.addChild(typeLabelShadow);
	// Add tower type label
	var typeLabel = new Text2(self.towerType.charAt(0).toUpperCase() + self.towerType.slice(1), {
		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);
		// Check if tower type can be placed (for poison and slow towers)
		var canPlace = canPlaceTowerType(self.towerType);
		// Hide tower icon instead of making it transparent
		self.visible = canAfford && canPlace;
		// Add animated scaling to tower icon graphics to make them more prominent
		if (!self.iconAnimated && self.visible) {
			self.iconAnimated = true;
			// Apply smooth scaling animation to the base graphics (first child which is the tower image)
			if (self.children[0]) {
				var baseGraphics = self.children[0];
				// Store original scale if not already stored
				if (!baseGraphics.originalScaleX) {
					baseGraphics.originalScaleX = baseGraphics.scaleX;
					baseGraphics.originalScaleY = baseGraphics.scaleY;
				}
				// Animate to slightly larger size for better visibility
				tween(baseGraphics, {
					scaleX: baseGraphics.originalScaleX * 1.05,
					scaleY: baseGraphics.originalScaleY * 1.05
				}, {
					duration: 600,
					easing: tween.easeInOut,
					onFinish: function onFinish() {
						// Create subtle breathing animation
						var _breatheAnimation = function breatheAnimation() {
							if (self.visible && baseGraphics.parent) {
								tween(baseGraphics, {
									scaleX: baseGraphics.originalScaleX * 1.08,
									scaleY: baseGraphics.originalScaleY * 1.08
								}, {
									duration: 1200,
									easing: tween.easeInOut,
									onFinish: function onFinish() {
										if (self.visible && baseGraphics.parent) {
											tween(baseGraphics, {
												scaleX: baseGraphics.originalScaleX * 1.05,
												scaleY: baseGraphics.originalScaleY * 1.05
											}, {
												duration: 1200,
												easing: tween.easeInOut,
												onFinish: function onFinish() {
													if (self.visible && baseGraphics.parent) {
														_breatheAnimation();
													}
												}
											});
										}
									}
								});
							}
						};
						_breatheAnimation();
					}
				});
			}
		} else if (!self.visible && self.iconAnimated) {
			// Reset animation state when tower becomes invisible
			self.iconAnimated = false;
			if (self.children[0]) {
				var baseGraphics = self.children[0];
				tween.stop(baseGraphics, {
					scaleX: true,
					scaleY: true
				});
				if (baseGraphics.originalScaleX) {
					baseGraphics.scaleX = baseGraphics.originalScaleX;
					baseGraphics.scaleY = baseGraphics.originalScaleY;
				}
			}
		}
		// Add pulsing animation for tower icons before game starts
		if (!waveIndicator.gameStarted && self.visible && !self.isPulsing) {
			var _pulseIcon = function pulseIcon() {
				if (!waveIndicator.gameStarted && self.visible) {
					// First pulse - grow and move up slightly
					tween(self, {
						scaleX: self.scaleX * 1.4,
						scaleY: self.scaleY * 1.4,
						x: self.x + 10,
						// Move slightly to the right
						y: self.y - 15
					}, {
						duration: 800,
						easing: tween.easeInOut,
						onFinish: function onFinish() {
							if (!waveIndicator.gameStarted && self.visible) {
								// Second pulse - shrink back and return to original position
								tween(self, {
									scaleX: self.scaleX / 1.4,
									scaleY: self.scaleY / 1.4,
									x: self.x - 10,
									// Move back to original position
									y: self.y + 15
								}, {
									duration: 800,
									easing: tween.easeInOut,
									onFinish: function onFinish() {
										// Wait before next pulse cycle
										tween({}, {}, {
											duration: 600,
											onFinish: function onFinish() {
												if (!waveIndicator.gameStarted && self.visible) {
													_pulseIcon(); // Continue pulsing
												} else {
													self.isPulsing = false;
												}
											}
										});
									}
								});
							} else {
								self.isPulsing = false;
							}
						}
					});
				} else {
					self.isPulsing = false;
				}
			};
			self.isPulsing = true;
			_pulseIcon();
		} else if (waveIndicator.gameStarted && self.isPulsing) {
			// Stop pulsing when game starts
			tween.stop(self, {
				scaleX: true,
				scaleY: true
			});
			self.isPulsing = false;
		}
	};
	return self;
});
var Tower = Container.expand(function (id) {
	var self = Container.call(this);
	self.id = id || 'default';
	self.level = 1;
	self.maxLevel = 10;
	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 return base range regardless of level - range stays constant when upgrading
		switch (self.id) {
			case 'sniper':
				// Sniper: fixed base range of 5
				return 5 * CELL_SIZE;
			case 'splash':
				// Splash: fixed base range of 3.0
				return 3.0 * CELL_SIZE;
			case 'rapid':
				// Rapid: fixed base range of 2.7
				return 2.7 * CELL_SIZE;
			case 'slow':
				// Slow: fixed base range of 3.5
				return 3.5 * CELL_SIZE;
			case 'poison':
				// Poison: fixed base range of 3.2
				return 3.2 * CELL_SIZE;
			default:
				// Default: fixed base range of 3
				return 3 * CELL_SIZE;
		}
	};
	self.cellsInRange = [];
	self.fireRate = 45; // Reduced from 60 to 45 for faster default tower firing
	self.bulletSpeed = 5;
	self.damage = 10;
	self.lastFired = 0;
	self.targetEnemy = null;
	switch (self.id) {
		case 'rapid':
			self.fireRate = 20; // Reduced from 30 to 20 for much faster rapid firing
			self.damage = 5;
			self.range = 2.7 * CELL_SIZE; // Match new getRange base
			self.bulletSpeed = 7;
			break;
		case 'sniper':
			self.fireRate = 75; // Reduced from 90 to 75 for faster sniper firing
			self.damage = 25;
			self.range = 5 * CELL_SIZE;
			self.bulletSpeed = 25;
			break;
		case 'splash':
			self.fireRate = 60; // Reduced from 75 to 60 for faster splash firing
			self.damage = 15;
			self.range = 2 * CELL_SIZE;
			self.bulletSpeed = 4;
			break;
		case 'slow':
			self.fireRate = 40; // Reduced from 50 to 40 for faster slow tower firing
			self.damage = 15;
			self.range = 3.5 * CELL_SIZE;
			self.bulletSpeed = 5;
			break;
		case 'poison':
			self.fireRate = 55; // Reduced from 70 to 55 for faster poison tower firing
			self.damage = 12;
			self.range = 3.2 * CELL_SIZE;
			self.bulletSpeed = 5;
			break;
	}
	// --- FAKE PROGRESSION: Do NOT change any stats on upgrade! All stats remain fixed regardless of level ---
	// Get appropriate asset for this tower type
	var assetId = 'tower_' + self.id;
	var baseGraphics = self.attachAsset(assetId, {
		anchorX: 0.5,
		anchorY: 0.5,
		scaleX: 1.4,
		scaleY: 1.4
	});
	// Make rapid tower base visible, hide others
	baseGraphics.alpha = self.id === 'rapid' || self.id === 'splash' || self.id === 'default' || self.id === 'sniper' ? 1 : 0;
	// Move rapid tower base down slightly
	if (self.id === 'rapid') {
		baseGraphics.y = 15; // Move base image down by 15 pixels
	}
	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('tower_level', {
			anchorX: 0.5,
			anchorY: 0.5
		});
		outlineCircle.width = dotSize + 4;
		outlineCircle.height = dotSize + 4;
		outlineCircle.tint = 0x000000;
		var towerLevelIndicator = dot.attachAsset('tower_level', {
			anchorX: 0.5,
			anchorY: 0.5
		});
		towerLevelIndicator.width = dotSize;
		towerLevelIndicator.height = dotSize;
		towerLevelIndicator.tint = 0xCCCCCC;
		dot.x = -CELL_SIZE + dotSpacing * (i + 1) + 10; // Moved slightly to the right
		dot.y = CELL_SIZE * 0.7;
		// Initially hide all dots, only show them when tower reaches that level
		dot.visible = false;
		self.addChild(dot);
		levelIndicators.push(dot);
	}
	var gunContainer = new Container();
	self.addChild(gunContainer);
	// Get appropriate defense asset for this tower type
	var defenseAssetId = 'defense_' + self.id;
	var gunGraphics = gunContainer.attachAsset(defenseAssetId, {
		anchorX: 0.5,
		anchorY: 0.5,
		scaleX: self.id === 'sniper' ? 1.1 : 1.3,
		scaleY: self.id === 'sniper' ? 1.1 : 1.3
	});
	// Poison tower defense graphics now visible
	if (self.id === 'poison') {
		gunGraphics.alpha = 1;
	}
	// Slow tower defense graphics now visible
	if (self.id === 'slow') {
		gunGraphics.alpha = 1;
	}
	self.updateLevelIndicators = function () {
		for (var i = 0; i < maxDots; i++) {
			var dot = levelIndicators[i];
			var towerLevelIndicator = dot.children[1];
			if (i < self.level) {
				// Show star and make it active (white)
				dot.visible = true;
				towerLevelIndicator.tint = 0xFFFFFF;
			} else {
				// Hide stars that are above the current level
				dot.visible = false;
			}
		}
	};
	self.updateLevelIndicators();
	// Add upgrade warning indicator
	var upgradeWarning = self.attachAsset('upgrade_warning', {
		anchorX: 0.5,
		anchorY: 0.5,
		width: 40,
		height: 40
	});
	upgradeWarning.x = -CELL_SIZE * 1.1; // Position further left, outside tower graphic
	upgradeWarning.y = -CELL_SIZE * 1.1; // Position further up, outside tower graphic
	upgradeWarning.visible = false; // Hidden by default
	upgradeWarning.tint = 0xFFD700; // Gold color for upgrade indication
	self.upgradeWarning = upgradeWarning;
	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 () {
		// Prevent upgrading before game starts
		if (!waveIndicator || !waveIndicator.gameStarted) {
			var notification = game.addChild(new Notification("Oyun başlamadan kuleler yükseltilemez!"));
			notification.x = 2048 / 2;
			notification.y = grid.height - 50;
			return false;
		}
		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) * 4); // Increase cost for final upgrade
			} else {
				upgradeCost = Math.floor(baseUpgradeCost * Math.pow(2, self.level - 1));
			}
			if (gold >= upgradeCost) {
				setGold(gold - upgradeCost);
				self.level++;
				// --- FAKE PROGRESSION: Do NOT change any gameplay stats on upgrade ---
				// self.damage, self.bulletSpeed, self.fireRate, self.range, etc. remain fixed!
				// Only update visual indicators
				self.refreshCellsInRange();
				self.updateLevelIndicators();
				//Play tower upgrade sound
				LK.getSound('tower_upgrade').play();
				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("Yükseltmek için yeterli altın yok!"));
				notification.x = 2048 / 2;
				notification.y = grid.height - 50;
				return false;
			}
		}
		return false;
	};
	self.findTarget = function () {
		// Cache last target if still valid and in range, but exclude vex and findik enemies
		if (self.targetEnemy && self.targetEnemy.parent && self.targetEnemy.health > 0 && self.targetEnemy.type !== 'vex' && self.targetEnemy.type !== 'findik') {
			if (self.isInRange(self.targetEnemy)) {
				return self.targetEnemy;
			}
		}
		var closestEnemy = null;
		var closestScore = Infinity;
		var towerRange = self.getRange();
		var rangeSquared = towerRange * towerRange; // Cache range squared
		// Use spatial partitioning to get only nearby enemies
		var nearbyEnemies = spatialGrid.getEnemiesInRange(self.x, self.y, towerRange);
		for (var i = 0; i < nearbyEnemies.length; i++) {
			var enemy = nearbyEnemies[i];
			if (!enemy.parent || enemy.health <= 0) continue;
			// Skip vex and findik enemies - towers ignore them completely
			// Fındık enemies are completely immune and should not be targeted at all
			if (enemy.type === 'vex' || enemy.type === 'findik') continue;
			// Kırık enemies can now be targeted like other enemies
			var dx = enemy.x - self.x;
			var dy = enemy.y - self.y;
			var distanceSquared = dx * dx + dy * dy;
			// Check if enemy is in range using squared distance (faster than sqrt)
			if (distanceSquared <= rangeSquared) {
				// 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 goalDx = enemy.flyingTarget.x - enemy.cellX;
						var goalDy = enemy.flyingTarget.y - enemy.cellY;
						var distToGoalSquared = goalDx * goalDx + goalDy * goalDy; // Use squared distance
						// Use squared distance to goal as score
						if (distToGoalSquared < closestScore) {
							closestScore = distToGoalSquared;
							closestEnemy = enemy;
						}
					} else {
						// If no flying target yet (shouldn't happen), prioritize by distance to tower
						if (distanceSquared < closestScore) {
							closestScore = distanceSquared;
							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 () {
		// Clean up enemy targeting arrays more frequently for responsive firing
		if (LK.ticks % 120 === 0) {
			// Every 2 seconds for more responsive targeting
			if (self.targetEnemy && (!self.targetEnemy.parent || self.targetEnemy.health <= 0)) {
				self.targetEnemy = null;
			}
			// Clean up invalid bullets from enemy targeting arrays
			if (self.targetEnemy && self.targetEnemy.bulletsTargetingThis) {
				self.targetEnemy.bulletsTargetingThis = self.targetEnemy.bulletsTargetingThis.filter(function (bullet) {
					return bullet && bullet.parent && bullet.targetEnemy === self.targetEnemy;
				});
			}
		}
		// Only find new target every 2 frames to reduce calculation frequency
		if (LK.ticks % 2 === 0 || !self.targetEnemy) {
			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);
			// Only rotate gun for non-poison and non-slow towers
			if (self.id !== 'poison' && self.id !== 'slow') {
				gunContainer.rotation = angle;
			}
			if (LK.ticks - self.lastFired >= self.fireRate) {
				self.fire();
				self.lastFired = LK.ticks;
			}
		}
		// Continuous poison cloud animation for poison towers
		if (self.id === 'poison') {
			// Check if black screen is active - only for wave 7
			var isBlackScreenActive = fadeToBlackStarted && bossWaveCompleted && currentWave === 7;
			if (!isBlackScreenActive) {
				self.poisonCloudTimer++;
				// Count poison towers to balance animation frequency
				var poisonTowerCount = 0;
				for (var t = 0; t < towers.length; t++) {
					if (towers[t].id === 'poison') {
						poisonTowerCount++;
					}
				}
				// Adjust frequency based on poison tower count - reduce frequency with more towers
				var poisonFrequency = 20; // Reduced base frequency for faster animation
				// Significantly reduce animation frequency for waves 5-8 to improve performance
				if (currentWave >= 5 && currentWave <= 8) {
					poisonFrequency = 50; // Much slower animation for waves 5-8
				} else if (poisonTowerCount > 3) {
					// Increase interval (reduce frequency) when more than 3 poison towers
					poisonFrequency = 20 + (poisonTowerCount - 3) * 10; // Reduced multiplier for faster animation
				}
				// Create poison clouds at adjusted frequency
				if (self.poisonCloudTimer % poisonFrequency === 0) {
					self.createContinuousPoisonClouds();
				}
			}
		}
		// Continuous motor exhaust animation for splash towers
		if (self.id === 'splash') {
			// Check if black screen is active - only for wave 7
			var isBlackScreenActive = fadeToBlackStarted && bossWaveCompleted && currentWave === 7;
			if (!isBlackScreenActive) {
				self.exhaustTimer++;
				// Count splash towers to balance animation frequency
				var splashTowerCount = 0;
				for (var t = 0; t < towers.length; t++) {
					if (towers[t].id === 'splash') {
						splashTowerCount++;
					}
				}
				// Adjust frequency based on splash tower count - reduce frequency with more towers
				var exhaustFrequency = 25; // Base frequency for exhaust animation
				// Reduce frequency significantly for waves 8+ to minimize animation load
				if (currentWave >= 8) {
					exhaustFrequency = 120; // Significantly increased frequency for waves 8+
				}
				if (splashTowerCount > 2) {
					// Increase interval (reduce frequency) when more than 2 splash towers
					exhaustFrequency = exhaustFrequency + (splashTowerCount - 2) * 8;
				}
				// Create motor exhaust at adjusted frequency
				if (self.exhaustTimer % exhaustFrequency === 0) {
					self.createMotorExhaust();
				}
			}
		}
		// Continuous flame animation for slow towers
		if (self.id === 'slow') {
			// Check if black screen is active - only for wave 7
			var isBlackScreenActive = fadeToBlackStarted && bossWaveCompleted && currentWave === 7;
			if (!isBlackScreenActive) {
				self.flameTimer++;
				// Count slow towers to balance animation frequency
				var slowTowerCount = 0;
				for (var t = 0; t < towers.length; t++) {
					if (towers[t].id === 'slow') {
						slowTowerCount++;
					}
				}
				// Adjust frequency based slow tower count - reduce frequency with more towers
				var flameFrequency = 18; // Increased base frequency for faster flame animation (reduced from 24 to 18)
				// Significantly reduce animation frequency for waves 5-8 to improve performance
				if (currentWave >= 5 && currentWave <= 8) {
					flameFrequency = 45; // Faster animation for waves 5-8 (reduced from 60 to 45)
				} else if (slowTowerCount > 2) {
					// Increase interval (reduce frequency) when more than 2 slow towers
					flameFrequency = 18 + (slowTowerCount - 2) * 6; // Reduced base and multiplier for faster animation
				}
				// Create continuous flames at adjusted frequency
				if (self.flameTimer % flameFrequency === 0) {
					self.createContinuousFlames();
				}
			}
		}
		// Continuous exhaust animation for rapid towers
		if (self.id === 'rapid') {
			// Check if black screen is active - only for wave 7
			var isBlackScreenActive = fadeToBlackStarted && bossWaveCompleted && currentWave === 7;
			if (!isBlackScreenActive) {
				self.exhaustTimer++;
				// Count rapid towers to balance animation frequency
				var rapidTowerCount = 0;
				for (var t = 0; t < towers.length; t++) {
					if (towers[t].id === 'rapid') {
						rapidTowerCount++;
					}
				}
				// Adjust frequency based on rapid tower count - reduce frequency with more towers
				var exhaustFrequency = 35; // Base frequency for exhaust animation (moderate speed)
				if (rapidTowerCount > 1) {
					// Increase interval (reduce frequency) when more than 1 rapid tower
					exhaustFrequency = 35 + (rapidTowerCount - 1) * 10;
				}
				// Create exhaust at adjusted frequency
				if (self.exhaustTimer % exhaustFrequency === 0) {
					self.createRapidExhaust();
				}
			}
		}
		// Check if tower can be upgraded and has enough gold
		self.checkUpgradeAvailability();
	};
	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 () {
		// Slow towers apply area damage to ALL enemies in range
		if (self.id === 'slow') {
			// Apply slow effect and area damage to all enemies in range
			var slowRadius = self.getRange();
			var affectedEnemies = [];
			// Find all enemies within slow radius from tower
			for (var i = 0; i < enemies.length; i++) {
				var nearbyEnemy = enemies[i];
				if (nearbyEnemy && nearbyEnemy.parent && nearbyEnemy.health > 0 && !nearbyEnemy.isFlying) {
					var dx = nearbyEnemy.x - self.x;
					var dy = nearbyEnemy.y - self.y;
					var distance = Math.sqrt(dx * dx + dy * dy);
					if (distance <= slowRadius) {
						affectedEnemies.push(nearbyEnemy);
					}
				}
			}
			// Apply area damage to only one enemy (the first one in the list)
			if (affectedEnemies.length > 0) {
				var damagedEnemy = affectedEnemies[0];
				// Apply area damage to only one enemy (including immune ones)
				damagedEnemy.health -= self.damage;
				if (damagedEnemy.health <= 0) {
					damagedEnemy.health = 0;
				} else {
					damagedEnemy.healthBar.width = damagedEnemy.health / damagedEnemy.maxHealth * 70;
				}
				// Play area damage sound every 4 seconds (240 frames at 60 FPS)
				if (!self.lastAreaSoundTime) {
					self.lastAreaSoundTime = 0;
				}
				if (LK.ticks - self.lastAreaSoundTime >= 240) {
					LK.getSound('alanhasar').play();
					self.lastAreaSoundTime = LK.ticks;
				}
			}
			// Play welcometohell sound only once for the first enemy entering slow tower area damage (excluding blue enemies, Wave 5, Wave 7 big enemy, fex, and fındık enemies)
			if (affectedEnemies.length > 0 && !welcomeToHellSoundPlayed) {
				// Filter out blue enemies, Wave 5 enemies, Wave 7 big enemy, fex, and fındık enemies from welcometohell sound triggering
				var validEnemiesForWelcome = affectedEnemies.filter(function (enemy) {
					// Exclude big enemy in wave 7
					if (enemy.waveNumber === 7 && enemy.type === 'big') return false;
					// Exclude fex and fındık enemies
					if (enemy.type === 'fex' || enemy.type === 'findik') return false;
					return enemy.type !== 'blue' && enemy.waveNumber !== 5 && enemy.waveNumber !== 7;
				});
				if (validEnemiesForWelcome.length > 0) {
					welcomeToHellSoundPlayed = true;
					LK.getSound('welcometohell').play();
				}
			}
			// Count enemies entering slow tower area damage (bronz sound removed for blue enemies and all Wave 5 enemies)
			if (affectedEnemies.length > 0) {
				// Filter out blue enemies and all Wave 5 enemies from bronz sound triggering AND counting
				var validEnemiesForBronz = affectedEnemies.filter(function (enemy) {
					return enemy.type !== 'blue' && enemy.waveNumber !== 5;
				});
				if (validEnemiesForBronz.length > 0) {
					slowAreaEnemyCount += validEnemiesForBronz.length;
				}
			}
			// Track enemies entering and exiting slow area
			for (var i = 0; i < affectedEnemies.length; i++) {
				var affectedEnemy = affectedEnemies[i];
				if (enemiesInSlowArea.indexOf(affectedEnemy) === -1) {
					enemiesInSlowArea.push(affectedEnemy);
				}
			}
			// Apply slow effect to all affected enemies
			for (var i = 0; i < affectedEnemies.length; i++) {
				var affectedEnemy = affectedEnemies[i];
				// Create flame animation for each affected enemy using particle pool
				var flameCount = 6; // Increased from 4 to 6 to enhance visual effect
				for (var flameIdx = 0; flameIdx < flameCount; flameIdx++) {
					var flameParticle = getFireParticle();
					var flameGraphics = flameParticle.fireGraphics;
					flameGraphics.width = 12 + Math.random() * 16; // Reduced size from 15+20 to 12+16
					flameGraphics.height = flameGraphics.width;
					// Flame color palette
					var flameColors = [0xFF4500, 0xFF6600, 0xFF8800, 0xFFAA00, 0xFFCC00];
					flameGraphics.tint = flameColors[Math.floor(Math.random() * flameColors.length)];
					// Position flame particles around the enemy
					var angle = flameIdx / flameCount * Math.PI * 2 + Math.random() * 0.5;
					var distance = Math.random() * 30; // Reduced distance from 40 to 30
					flameParticle.x = affectedEnemy.x + Math.cos(angle) * distance;
					flameParticle.y = affectedEnemy.y + Math.sin(angle) * distance;
					flameParticle.alpha = 0.8; // Reduced from 0.9 to 0.8
					flameParticle.scaleX = 0.4 + Math.random() * 0.4; // Reduced from 0.5+0.5 to 0.4+0.4
					flameParticle.scaleY = 0.4 + Math.random() * 0.4;
					game.addChild(flameParticle);
					// Animate flame flickering and burning out
					tween(flameParticle, {
						alpha: 0,
						scaleX: flameParticle.scaleX * 1.6,
						// Reduced from 1.8 to 1.6
						scaleY: flameParticle.scaleY * 1.6,
						y: flameParticle.y - 15 - Math.random() * 20 // Reduced from 20+30 to 15+20
					}, {
						duration: 500 + Math.random() * 300,
						//{tm} // Reduced from 600+400 to 500+300
						easing: tween.easeOut,
						onFinish: function onFinish() {
							// Particle cleanup now handled by periodic systems
						}
					});
				}
				// Apply slow effect to all enemies except fex enemies (immune enemies can now be slowed)
				if (affectedEnemy.type !== 'fex') {
					var slowPct = 0.25;
					if (self.level !== undefined) {
						// Scale: 25% at level 1, 30% at 2, 32% at 3, 35% at 4, 37% at 5, 40% at 6
						var slowLevels = [0.25, 0.3, 0.32, 0.35, 0.37, 0.4];
						var idx = Math.max(0, Math.min(5, self.level - 1));
						slowPct = slowLevels[idx];
					}
					if (!affectedEnemy.slowed) {
						affectedEnemy.originalSpeed = affectedEnemy.speed;
						affectedEnemy.speed *= 1 - slowPct; // Slow by X%
						affectedEnemy.slowed = true;
						affectedEnemy.slowDuration = 180; // 3 seconds at 60 FPS
					} else {
						affectedEnemy.slowDuration = 180; // Reset duration
					}
				} else {
					// Krk sound moved to splash tower bullet hit logic - not played here anymore
				}
			}
			return; // Exit early for slow towers
		}
		if (self.targetEnemy) {
			var potentialDamage = 0;
			// Only count bullets that are very close to hitting to reduce firing delays
			for (var i = 0; i < self.targetEnemy.bulletsTargetingThis.length; i++) {
				var bullet = self.targetEnemy.bulletsTargetingThis[i];
				if (bullet && bullet.targetEnemy === self.targetEnemy) {
					var dx = bullet.x - self.targetEnemy.x;
					var dy = bullet.y - self.targetEnemy.y;
					var bulletDistance = Math.sqrt(dx * dx + dy * dy);
					// Only count bullets that are very close (within 2 bullet speeds) to hitting
					if (bulletDistance < bullet.speed * 2) {
						potentialDamage += bullet.damage;
					}
				}
			}
			if (self.targetEnemy.health > potentialDamage) {
				var bulletX = self.x + Math.cos(gunContainer.rotation) * 40;
				var bulletY = self.y + Math.sin(gunContainer.rotation) * 40;
				var bullet = new Bullet(bulletX, bulletY, self.targetEnemy, self.damage, self.bulletSpeed);
				// Set bullet type based on tower type
				bullet.type = self.id;
				// For default towers, randomly use bullet_5 asset 20% of the time
				if (self.id === 'default' && Math.random() < 0.2) {
					bullet.isBullet5 = true;
					// Replace default bullet graphics with bullet_5 asset
					if (bullet.children[0].parent) {
						bullet.removeChild(bullet.children[0]);
					}
					var bullet5Graphics = bullet.attachAsset('bullet_5', {
						anchorX: 0.5,
						anchorY: 0.5
					});
				}
				// Customize bullet appearance based on tower type
				switch (self.id) {
					case 'rapid':
						bullet.children[0].tint = 0x00AAFF;
						bullet.children[0].width = 9;
						bullet.children[0].height = 9;
						break;
					case 'sniper':
						// Remove old bullet graphics and add sniper-specific asset
						if (bullet.children[0].parent) {
							bullet.removeChild(bullet.children[0]);
						}
						var sniperBulletGraphics = bullet.attachAsset('bullet_sniper', {
							anchorX: 0.5,
							anchorY: 0.5
						});
						sniperBulletGraphics.width = 9;
						sniperBulletGraphics.height = 15;
						sniperBulletGraphics.tint = 0xFF5500; // Orange color for sniper bullets
						break;
					case 'splash':
						// Play goddamit sound only once per wave on first splash bullet creation for normal enemies only
						if (!window.splashBulletSoundPlayed && self.targetEnemy.type === 'normal') {
							window.splashBulletSoundPlayed = true;
							// Delay the sound by 1200ms for clear speech
							tween({}, {}, {
								duration: 1200,
								onFinish: function onFinish() {
									LK.getSound('goddamit').play();
								}
							});
						}
						// Remove old bullet graphics and add splash-specific asset
						if (bullet.children[0].parent) {
							bullet.removeChild(bullet.children[0]);
						}
						var splashBulletGraphics = bullet.attachAsset('bullet_splash', {
							anchorX: 0.5,
							anchorY: 0.5
						});
						// Reduce splash bullet animation complexity to minimize load
						// Apply much smaller bullet animation with greatly reduced movement for splash bullets
						bullet.animationReductionFactor = 0.1; // Reduce movement animation to 10% for splash bullets (reduced from 30%)
						break;
					case 'poison':
						// Hide the poison bullet graphic
						bullet.children[0].alpha = 0;
						break;
				}
				game.addChild(bullet);
				bullets.push(bullet);
				self.targetEnemy.bulletsTargetingThis.push(bullet);
				//Play tower shooting sound (except for poison and slow towers)
				if (self.id !== 'poison' && self.id !== 'slow') {
					// Play wifi sound for default tower bullets targeting bagışıkdüşman - only once per wave
					if (self.id === 'default' && self.targetEnemy && self.targetEnemy.isImmune && !wifiSoundPlayedThisWave) {
						wifiSoundPlayedThisWave = true;
						LK.getSound('wifi').play();
						// Play taksi sound for default tower bullet_5 theme targeting bagışıkdüşman - only once per wave
					} else if (self.id === 'default' && bullet.isBullet5 && self.targetEnemy && self.targetEnemy.isImmune && !taksiSoundPlayedThisWave) {
						taksiSoundPlayedThisWave = true;
						getPooledSound('taksi').play(); // Play taksi sound for default tower bullet_5 theme targeting bagışıkdüşman - only once per wave
						// Play gözlük sound for sniper tower bullets targeting bagışıkdüşman on 1st hit - only once per wave
					} else if (self.id === 'sniper' && self.targetEnemy && self.targetEnemy.isImmune) {
						sniperBulletImmuneHitCount++;
						if (sniperBulletImmuneHitCount === 1 && !gözlükSoundPlayedThisWave) {
							gözlükSoundPlayedThisWave = true;
							// Delay the gzlk sound by 2000ms (2 seconds)
							tween({}, {}, {
								duration: 2000,
								onFinish: function onFinish() {
									LK.getSound('gozluk').play();
								}
							});
						}
						// Play shy sound for sniper tower bullets targeting bagışıkdüşman on 3rd hit - only once per wave
						if (typeof window.sniperImmuneHitCounter === 'undefined') {
							window.sniperImmuneHitCounter = 0;
						}
						window.sniperImmuneHitCounter++;
						if (window.sniperImmuneHitCounter === 3 && !shySoundPlayedThisWave) {
							shySoundPlayedThisWave = true;
							// Delay the shy sound by 2000ms (2 seconds)
							tween({}, {}, {
								duration: 2000,
								onFinish: function onFinish() {
									try {
										LK.getSound('shy').play();
									} catch (e) {
										console.log("Error playing shy sound:", e);
									}
								}
							});
						}
						LK.getSound('tower_shoot').play();
						// Play krk sound for splash tower bullets targeting bagışıkdüşman on 2nd hit - only once per wave
					} else if (self.id === 'splash' && self.targetEnemy && self.targetEnemy.isImmune) {
						if (typeof window.splashImmuneHitCounter === 'undefined') {
							window.splashImmuneHitCounter = 0;
						}
						window.splashImmuneHitCounter++;
						if (window.splashImmuneHitCounter === 2 && !window.krkSoundPlayedThisWave) {
							window.krkSoundPlayedThisWave = true;
							try {
								LK.getSound('krk').play();
							} catch (e) {
								console.log("Error playing krk sound:", e);
							}
						}
						LK.getSound('tower_shoot').play();
						// Play vasiyet sound for rapid tower bullets targeting bagışıkdüşman on 3rd hit - only once per wave
					} else if (self.id === 'rapid' && self.targetEnemy && self.targetEnemy.isImmune) {
						rapidBulletImmuneHitCount++;
						if (rapidBulletImmuneHitCount === 3 && !vasiyetSoundPlayedThisWave) {
							vasiyetSoundPlayedThisWave = true;
							// Delay the vasiyet sound by 3000ms (3 seconds)
							tween({}, {}, {
								duration: 3000,
								onFinish: function onFinish() {
									LK.getSound('vasiyet').play();
								}
							});
						} else {
							LK.getSound('tower_shoot').play();
						}
					} else {
						LK.getSound('tower_shoot').play();
					}
				}
				// --- Fire recoil effect for gunContainer (not for poison towers) ---
				if (self.id !== 'poison') {
					// 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;
		// Hide the placement square for this position
		if (waveIndicator && waveIndicator.placementFrame) {
			var placementSquares = waveIndicator.placementFrame.children;
			// Define the placement positions to match with squares
			var placementPositions = [{
				x: 11,
				y: 6
			},
			// First square
			{
				x: 11,
				y: 11
			},
			// Second square
			{
				x: 11,
				y: 16
			},
			// Third square
			{
				x: 11,
				y: 21
			},
			// Fourth square
			{
				x: 11,
				y: 26
			},
			// Fifth square
			{
				x: 11,
				y: 31
			} // Sixth square
			];
			// Find which placement square corresponds to this position
			for (var i = 0; i < placementPositions.length; i++) {
				if (placementPositions[i].x === gridX && placementPositions[i].y === gridY) {
					// Hide the corresponding placement square
					if (placementSquares[i]) {
						placementSquares[i].visible = false;
					}
					break;
				}
			}
		}
		// Only set cell type to 1 (wall) for non-poison towers
		// Poison towers don't block enemy movement
		if (self.id !== 'poison') {
			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();
		// Only invalidate pathfinding cache for non-poison towers (since poison towers don't block paths)
		if (self.id !== 'poison') {
			pathfindingCache = null; // Invalidate cache when non-poison towers are placed or removed
		}
		// Initialize continuous poison cloud animation for poison towers
		if (self.id === 'poison') {
			self.poisonCloudTimer = 0;
			self.createContinuousPoisonClouds = function () {
				// Check if black screen is active - only for wave 7
				var isBlackScreenActive = fadeToBlackStarted && bossWaveCompleted && currentWave === 7;
				if (isBlackScreenActive) {
					return; // Hide poison animation during black screen
				}
				// Disable poison cloud animations for waves 12+ to prevent white screen
				if (currentWave >= 12) {
					return; // Skip poison cloud animation for waves 12+
				}
				// Create optimized poison cloud particles with significantly reduced count
				var cloudCount = 1; // Further reduced to 1 to minimize particle load
				for (var cloudIdx = 0; cloudIdx < cloudCount; cloudIdx++) {
					var poisonCloud = getPoisonCloudParticle();
					var cloudGraphics = poisonCloud.cloudGraphics;
					cloudGraphics.width = 20 + Math.random() * 25; // Smaller cloud size
					cloudGraphics.height = cloudGraphics.width;
					// Enhanced poison color palette with toxic variations
					var toxicColors = [0x00FF00, 0x00DD00, 0x00BB00, 0x228B22, 0x32CD32, 0x7CFC00, 0x9ACD32, 0x00FF7F];
					cloudGraphics.tint = toxicColors[Math.floor(Math.random() * toxicColors.length)];
					// Position cloud particles in optimized pattern around the tower
					var ringNumber = Math.floor(cloudIdx / 3); // Adjusted for new cloud count
					var angleInRing = cloudIdx % 3 * (Math.PI * 2 / 3) + Math.random() * 0.5; // Adjusted spacing
					var baseDistance = 30 + ringNumber * 15; // Smaller distance
					var distance = baseDistance + Math.random() * 15; // Reduced spread
					poisonCloud.x = self.x + Math.cos(angleInRing) * distance;
					poisonCloud.y = self.y + Math.sin(angleInRing) * distance;
					poisonCloud.alpha = 0.4 + Math.random() * 0.3; // More transparent
					poisonCloud.scaleX = 0.3 + Math.random() * 0.3; // Smaller initial scale
					poisonCloud.scaleY = 0.3 + Math.random() * 0.3;
					game.addChild(poisonCloud);
					// Optimized poison cloud animation with reduced complexity
					var targetScale = poisonCloud.scaleX * (1.8 + Math.random() * 1.0); // Smaller target scale
					// Create simplified swirling motion
					var swirl = Math.random() > 0.5 ? 1 : -1;
					var swirlAngle = angleInRing + swirl * (Math.PI * 1.0 + Math.random() * Math.PI * 0.4); // Reduced swirl
					var swirlRadius = distance * (0.6 + Math.random() * 0.2); // Tighter radius
					var targetX = self.x + Math.cos(swirlAngle) * swirlRadius + (Math.random() - 0.5) * 20; // Less spread
					var targetY = poisonCloud.y - (20 + Math.random() * 25); // Reduced vertical movement
					// Simplified pulsing effect
					var pulseScale = targetScale * (0.6 + Math.random() * 0.2); // Less pulsing variation
					var rotationSpeed = swirl * (Math.PI * 1.5 + Math.random() * Math.PI * 0.8); // Slower rotation
					tween(poisonCloud, {
						x: targetX,
						y: targetY,
						alpha: 0,
						scaleX: pulseScale,
						scaleY: pulseScale,
						rotation: rotationSpeed
					}, {
						duration: 750 + Math.random() * 300,
						// Shorter duration for faster cleanup
						easing: tween.easeOut,
						onFinish: function onFinish() {
							// Particle cleanup now handled by periodic systems
						}
					});
				}
			};
		}
		// Initialize motor exhaust particle effects for splash towers
		if (self.id === 'splash') {
			self.exhaustTimer = 0;
			self.createMotorExhaust = function () {
				// Check if black screen is active - only for wave 7
				var isBlackScreenActive = fadeToBlackStarted && bossWaveCompleted && currentWave === 7;
				if (isBlackScreenActive) {
					return; // Hide splash animation during black screen
				}
				// Disable motor exhaust animations for waves 12+ to prevent white screen
				if (currentWave >= 12) {
					return; // Skip motor exhaust animation for waves 12+
				}
				// Play motor exhaust sound effect
				LK.getSound('egzos').play();
				// Create motor exhaust particles at tower base left-center side (stationary position)
				var exhaustCount = enemies.length > 15 ? 4 : 6; // Further reduced count when many enemies
				// Reduce exhaust particle count for boss waves and waves 8+ to minimize animation load
				if (currentWave === 7 || currentWave >= 8) {
					exhaustCount = Math.floor(exhaustCount * 0.2); // Further reduce particle count for boss wave and waves 8+
				}
				for (var exhaustIdx = 0; exhaustIdx < exhaustCount; exhaustIdx++) {
					var exhaustParticle = getSmokeParticle();
					var exhaustGraphics = exhaustParticle.smokeGraphics;
					exhaustGraphics.width = 15 + Math.random() * 25;
					exhaustGraphics.height = exhaustGraphics.width;
					// Motor exhaust color palette - dark grays and blacks
					var exhaustColors = [0x2a2a2a, 0x1a1a1a, 0x404040, 0x303030, 0x505050];
					exhaustGraphics.tint = exhaustColors[Math.floor(Math.random() * exhaustColors.length)];
					// FIXED: Position exhaust at tower base left-center - completely stationary, not attached to gun
					var baseLeftOffset = -60; // Left from tower base center
					var baseCenterYOffset = 0; // At center level (no vertical offset)
					var exhaustSpread = 8 + Math.random() * 12; // Small random spread around base position
					// Use tower base position (self.x, self.y) directly, ignore gun rotation completely
					exhaustParticle.x = self.x + baseLeftOffset + (Math.random() - 0.5) * exhaustSpread;
					exhaustParticle.y = self.y + baseCenterYOffset + (Math.random() - 0.5) * exhaustSpread;
					exhaustParticle.alpha = 0.7 + Math.random() * 0.3;
					exhaustParticle.scaleX = 0.4 + Math.random() * 0.4;
					exhaustParticle.scaleY = 0.4 + Math.random() * 0.4;
					game.addChild(exhaustParticle);
					// Animate exhaust particles moving slightly left and fading (stationary emission)
					var targetX = exhaustParticle.x - 20 - Math.random() * 15; // Move slightly further left
					var targetY = exhaustParticle.y + (Math.random() - 0.5) * 10; // Small vertical variation
					tween(exhaustParticle, {
						x: targetX,
						y: targetY,
						alpha: 0,
						scaleX: exhaustParticle.scaleX * 2.0,
						scaleY: exhaustParticle.scaleY * 2.0
					}, {
						duration: 800 + Math.random() * 400,
						easing: tween.easeOut,
						onFinish: function onFinish() {
							// Particle cleanup now handled by periodic systems
						}
					});
				}
			};
		}
		// Initialize continuous flame animation for slow towers
		if (self.id === 'slow') {
			self.flameTimer = 0;
			self.createContinuousFlames = function () {
				// Check if black screen is active - only for wave 7
				var isBlackScreenActive = fadeToBlackStarted && bossWaveCompleted && currentWave === 7;
				if (isBlackScreenActive) {
					return; // Hide slow tower animation during black screen
				}
				// Disable flame animations for waves 12+ to prevent white screen
				if (currentWave >= 12) {
					return; // Skip flame animation for waves 12+
				}
				// Flame sound disabled for slow towers
				// LK.getSound('flame_sound').play();
				// Create continuous flame particles around the slow tower using particle pool
				var flameCount = 2; // Further reduced to 2 to minimize particle load
				for (var flameIdx = 0; flameIdx < flameCount; flameIdx++) {
					var flameParticle = getFireParticle();
					var flameGraphics = flameParticle.fireGraphics;
					flameGraphics.width = 12 + Math.random() * 20; // Further reduced flame size (was 15+25, now 12+20)
					flameGraphics.height = flameGraphics.width;
					// Enhanced flame color palette with intense fire colors
					var flameColors = [0xFF4500, 0xFF6600, 0xFF2200, 0xFF8800, 0xFFAA00, 0xFF0000, 0xCC4400, 0xDD3300];
					flameGraphics.tint = flameColors[Math.floor(Math.random() * flameColors.length)];
					// Position flame particles in multiple concentric circles around the tower
					var ringNumber = Math.floor(flameIdx / 6); // 3 rings of 6 particles each
					var angleInRing = flameIdx % 6 * (Math.PI * 2 / 6) + Math.random() * 0.6;
					var baseDistance = 35 + ringNumber * 20;
					var distance = baseDistance + Math.random() * 25;
					flameParticle.x = self.x + Math.cos(angleInRing) * distance;
					flameParticle.y = self.y + Math.sin(angleInRing) * distance;
					flameParticle.alpha = 0.7 + Math.random() * 0.3;
					flameParticle.scaleX = 0.6 + Math.random() * 0.5;
					flameParticle.scaleY = 0.6 + Math.random() * 0.5;
					game.addChild(flameParticle);
					// Reduced flame animation with flickering motion and upward movement
					var targetScale = flameParticle.scaleX * (1.8 + Math.random() * 1.2); // Smaller target scale
					// Create flickering motion around the tower
					var flicker = Math.random() > 0.5 ? 1 : -1;
					var flickerAngle = angleInRing + flicker * (Math.PI * 0.6 + Math.random() * Math.PI * 0.4); // Less flickering
					var flickerRadius = distance * (0.8 + Math.random() * 0.2); // Tighter radius
					var targetX = self.x + Math.cos(flickerAngle) * flickerRadius + (Math.random() - 0.5) * 25; // Less spread
					var targetY = flameParticle.y - (20 + Math.random() * 25); // Less vertical movement
					// Add pulsing effect by varying the target scale over time
					var pulseScale = targetScale * (0.8 + Math.random() * 0.4); // Less pulsing variation
					var rotationSpeed = flicker * (Math.PI * 2 + Math.random() * Math.PI * 1.5);
					tween(flameParticle, {
						x: targetX,
						y: targetY,
						alpha: 0,
						scaleX: pulseScale,
						scaleY: pulseScale,
						rotation: rotationSpeed
					}, {
						duration: 800 + Math.random() * 300,
						// Reduced duration from 1000+500 to 800+300
						easing: tween.easeOut,
						onFinish: function onFinish() {
							// Particle cleanup now handled by periodic systems
						}
					});
				}
			};
		}
		// Initialize exhaust animation for rapid towers
		if (self.id === 'rapid') {
			self.exhaustTimer = 0;
			self.createRapidExhaust = function () {
				// Check if black screen is active - only for wave 7
				var isBlackScreenActive = fadeToBlackStarted && bossWaveCompleted && currentWave === 7;
				if (isBlackScreenActive) {
					return; // Hide rapid tower animation during black screen
				}
				// Disable rapid exhaust animations for waves 12+ to prevent white screen
				if (currentWave >= 12) {
					return; // Skip rapid exhaust animation for waves 12+
				}
				// Create small black exhaust particles at the top of the rapid tower base
				var exhaustCount = 2; // Always 2 to minimize particle load
				for (var exhaustIdx = 0; exhaustIdx < exhaustCount; exhaustIdx++) {
					var exhaustParticle = getSmokeParticle();
					var exhaustGraphics = exhaustParticle.smokeGraphics;
					exhaustGraphics.width = 8 + Math.random() * 12; // Small exhaust particles
					exhaustGraphics.height = exhaustGraphics.width;
					// Dark exhaust colors - black and very dark gray
					var exhaustColors = [0x000000, 0x1a1a1a, 0x333333];
					exhaustGraphics.tint = exhaustColors[Math.floor(Math.random() * exhaustColors.length)];
					// Position exhaust higher above the rapid tower base
					var exhaustAngle = Math.random() * Math.PI * 2; // Random direction
					var exhaustDistance = 15 + Math.random() * 10; // Small spread from top center
					exhaustParticle.x = self.x + Math.cos(exhaustAngle) * exhaustDistance;
					exhaustParticle.y = self.y - 75 + Math.sin(exhaustAngle) * 5; // Higher above the tower base (moved from -70 to -75)
					exhaustParticle.alpha = 0.6 + Math.random() * 0.4; // More prominent exhaust (increased from 0.4+0.3 to 0.6+0.4)
					exhaustParticle.scaleX = 0.5 + Math.random() * 0.3; // Larger particles (increased from 0.3+0.2 to 0.5+0.3)
					exhaustParticle.scaleY = 0.5 + Math.random() * 0.3;
					game.addChild(exhaustParticle);
					// Animate exhaust particles moving upward and fading
					var targetY = exhaustParticle.y - (30 + Math.random() * 20); // Move upward
					var targetX = exhaustParticle.x + (Math.random() - 0.5) * 15; // Slight horizontal drift
					tween(exhaustParticle, {
						x: targetX,
						y: targetY,
						alpha: 0,
						scaleX: exhaustParticle.scaleX * 1.5,
						scaleY: exhaustParticle.scaleY * 1.5
					}, {
						duration: 800 + Math.random() * 400,
						easing: tween.easeOut,
						onFinish: function onFinish() {
							// Particle cleanup now handled by periodic systems
						}
					});
				}
			};
		}
	};
	self.checkUpgradeAvailability = function () {
		if (self.level >= self.maxLevel) {
			// Tower is at max level, hide warning
			if (self.upgradeWarning) {
				self.upgradeWarning.visible = false;
				if (self.iconAnimated) {
					self.upgradeWarning.visible = true;
				}
			}
			return;
		}
		// Calculate upgrade cost
		var baseUpgradeCost = getTowerCost(self.id);
		var upgradeCost;
		if (self.level === self.maxLevel - 1) {
			upgradeCost = Math.floor(baseUpgradeCost * Math.pow(2, self.level - 1) * 3.5 / 2);
		} else {
			upgradeCost = Math.floor(baseUpgradeCost * Math.pow(2, self.level - 1));
		}
		// Show warning if player has enough gold for upgrade AND game has started
		var canAffordUpgrade = gold >= upgradeCost && waveIndicator && waveIndicator.gameStarted;
		if (self.upgradeWarning) {
			if (canAffordUpgrade && !self.upgradeWarning.visible) {
				// Create pulsing animation
				var _pulseWarning = function pulseWarning() {
					if (self.upgradeWarning && self.upgradeWarning.visible) {
						tween(self.upgradeWarning, {
							scaleX: 1.3,
							scaleY: 1.3,
							alpha: 0.7
						}, {
							duration: 600,
							easing: tween.easeInOut,
							onFinish: function onFinish() {
								if (self.upgradeWarning && self.upgradeWarning.visible) {
									tween(self.upgradeWarning, {
										scaleX: 1,
										scaleY: 1,
										alpha: 1
									}, {
										duration: 600,
										easing: tween.easeInOut,
										onFinish: function onFinish() {
											// Continue pulsing if still visible
											if (self.upgradeWarning && self.upgradeWarning.visible) {
												_pulseWarning();
											}
										}
									});
								}
							}
						});
					}
				};
				// Start pulsing animation when warning becomes visible
				self.upgradeWarning.visible = true;
				self.upgradeWarning.alpha = 1;
				self.upgradeWarning.scaleX = 1;
				self.upgradeWarning.scaleY = 1;
				_pulseWarning();
			} else if (!canAffordUpgrade) {
				// Stop animation and hide warning
				if (self.upgradeWarning.visible) {
					tween.stop(self.upgradeWarning, {
						scaleX: true,
						scaleY: true,
						alpha: true
					});
					self.upgradeWarning.visible = false;
				}
			}
		}
	};
	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;
		// Remove old preview graphics and add new one with correct asset
		if (previewGraphics.parent) {
			self.removeChild(previewGraphics);
		}
		// Get appropriate asset for this tower type
		var previewAssetId = 'towerpreview_' + self.towerType;
		previewGraphics = self.attachAsset(previewAssetId, {
			anchorX: 0.5,
			anchorY: 0.5
		});
		previewGraphics.width = CELL_SIZE * 2.4;
		previewGraphics.height = CELL_SIZE * 2.4;
		// Set color based on tower type
		var towerColor = 0xFFFFFF; // Default white
		switch (self.towerType) {
			case 'rapid':
				towerColor = 0x00AAFF; // Blue
				break;
			case 'sniper':
				towerColor = 0xFF5500; // Orange
				break;
			case 'splash':
				towerColor = 0x33CC00; // Green
				break;
			case 'slow':
				towerColor = 0xFF0000; // Red
				break;
			case 'poison':
				towerColor = 0x00FFAA; // Cyan
				break;
			default:
				towerColor = 0xAAAAAA;
			// Gray for default
		}
		if (!self.canPlace || !self.hasEnoughGold) {
			previewGraphics.tint = 0xFF0000;
		} else {
			previewGraphics.tint = towerColor;
		}
		// --- FAKE PROGRESSION: TowerPreview always shows fixed stats, only level indicator is visual ---
	};
	self.updatePlacementStatus = function () {
		var validGridPlacement = false;
		// Define the exact placement squares where towers can be placed
		var allowedPlacements = [{
			x: 11,
			y: 6
		},
		// First placement square
		{
			x: 11,
			y: 11
		},
		// Second placement square  
		{
			x: 11,
			y: 16
		},
		// Third placement square
		{
			x: 11,
			y: 21
		},
		// Fourth placement square
		{
			x: 11,
			y: 26
		},
		// Fifth placement square
		{
			x: 11,
			y: 31
		} // Sixth placement square
		];
		// Check if current grid position matches any allowed placement
		for (var p = 0; p < allowedPlacements.length; p++) {
			var placement = allowedPlacements[p];
			if (self.gridX === placement.x && self.gridY === placement.y) {
				validGridPlacement = true;
				break;
			}
		}
		// If placement is valid, check if cells are actually available
		if (validGridPlacement) {
			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 && canPlaceTowerType(self.towerType);
		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 = 1.0; // Make background fully opaque to hide tower animations underneath
	var towerTypeText = new Text2(self.tower.id.charAt(0).toUpperCase() + self.tower.id.slice(1) + ' Tower', {
		size: 80,
		fill: 0xFFFFFF,
		weight: 800
	});
	towerTypeText.anchor.set(0, 0);
	towerTypeText.x = -840;
	towerTypeText.y = -160;
	self.addChild(towerTypeText);
	var statsText = new Text2('Level: ' + self.tower.level + '/' + self.tower.maxLevel + '\nDamage: ' + self.tower.damage + '\nFire Rate: ' + (60 / self.tower.fireRate).toFixed(1) + '/s', {
		size: 70,
		fill: 0xFFFFFF,
		weight: 400
	});
	statsText.anchor.set(0, 0.5);
	statsText.x = -840;
	statsText.y = 50;
	self.addChild(statsText);
	var buttonsContainer = new Container();
	buttonsContainer.x = 500;
	self.addChild(buttonsContainer);
	var upgradeButton = new Container();
	buttonsContainer.addChild(upgradeButton);
	var buttonBackground = upgradeButton.attachAsset('notification', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	buttonBackground.width = 500;
	buttonBackground.height = 150;
	var isMaxLevel = self.tower.level >= self.tower.maxLevel;
	// Exponential upgrade cost: base cost * (2 ^ (level-1)), scaled by tower base cost
	var baseUpgradeCost = getTowerCost(self.tower.id);
	var upgradeCost;
	if (isMaxLevel) {
		upgradeCost = 0;
	} else if (self.tower.level === self.tower.maxLevel - 1) {
		upgradeCost = Math.floor(baseUpgradeCost * Math.pow(2, self.tower.level - 1) * 3.5 / 2);
	} else {
		upgradeCost = Math.floor(baseUpgradeCost * Math.pow(2, self.tower.level - 1));
	}
	buttonBackground.tint = isMaxLevel ? 0x888888 : gold >= upgradeCost ? 0x00AA00 : 0x888888;
	var buttonText = new Text2(isMaxLevel ? 'Max Level' : 'Upgrade: ' + upgradeCost + ' gold', {
		size: 60,
		fill: 0xFFFFFF,
		weight: 800
	});
	buttonText.anchor.set(0.5, 0.5);
	upgradeButton.addChild(buttonText);
	var sellButton = new Container();
	buttonsContainer.addChild(sellButton);
	var sellButtonBackground = sellButton.attachAsset('notification', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	sellButtonBackground.width = 500;
	sellButtonBackground.height = 150;
	sellButtonBackground.tint = 0xCC0000;
	var totalInvestment = self.tower.getTotalValue ? self.tower.getTotalValue() : 0;
	var sellValue = getTowerSellValue(totalInvestment);
	var sellButtonText = new Text2('Sell: +' + sellValue + ' gold', {
		size: 60,
		fill: 0xFFFFFF,
		weight: 800
	});
	sellButtonText.anchor.set(0.5, 0.5);
	sellButton.addChild(sellButtonText);
	upgradeButton.y = -85;
	sellButton.y = 85;
	var closeButton = new Container();
	self.addChild(closeButton);
	var closeBackground = closeButton.attachAsset('notification', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	closeBackground.width = 90;
	closeBackground.height = 90;
	closeBackground.tint = 0xAA0000;
	var closeText = new Text2('X', {
		size: 68,
		fill: 0xFFFFFF,
		weight: 800
	});
	closeText.anchor.set(0.5, 0.5);
	closeButton.addChild(closeText);
	closeButton.x = menuBackground.width / 2 - 57;
	closeButton.y = -menuBackground.height / 2 + 57;
	upgradeButton.down = function (x, y, obj) {
		if (self.tower.level >= self.tower.maxLevel) {
			var notification = game.addChild(new Notification("Kule zaten en yüksek seviyede!"));
			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));
			}
			// --- FAKE PROGRESSION: Show visual damage progression on upgrade ---
			// Calculate fake visual damage based on new level
			var visualDamage = self.tower.damage;
			if (self.tower.level > 1) {
				// Show 20% damage increase per level for visual feedback
				var damageMultiplier = 1 + (self.tower.level - 1) * 0.2;
				visualDamage = Math.floor(self.tower.damage * damageMultiplier);
			}
			statsText.setText('Level: ' + self.tower.level + '/' + self.tower.maxLevel + '\nDamage: ' + visualDamage + '\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) {
		// Prevent tower selling until wave 8
		if (currentWave < 8) {
			var notification = game.addChild(new Notification("Tower selling is prohibited until wave 8!"));
			notification.x = 2048 / 2;
			notification.y = grid.height - 50;
			return;
		}
		var totalInvestment = self.tower.getTotalValue ? self.tower.getTotalValue() : 0;
		var sellValue = getTowerSellValue(totalInvestment);
		setGold(gold + sellValue);
		// Decrement tower placement counter
		towersPlacedCount--;
		//Play tower sell sound
		LK.getSound('tower_sell').play();
		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;
		// Show the placement square again for this position
		if (waveIndicator && waveIndicator.placementFrame) {
			var placementSquares = waveIndicator.placementFrame.children;
			// Define the placement positions to match with squares
			var placementPositions = [{
				x: 11,
				y: 6
			},
			// First square
			{
				x: 11,
				y: 11
			},
			// Second square
			{
				x: 11,
				y: 16
			},
			// Third square
			{
				x: 11,
				y: 21
			},
			// Fourth square
			{
				x: 11,
				y: 26
			},
			// Fifth square
			{
				x: 11,
				y: 31
			} // Sixth square
			];
			// Find which placement square corresponds to this tower's position
			for (var i = 0; i < placementPositions.length; i++) {
				if (placementPositions[i].x === gridX && placementPositions[i].y === gridY) {
					// Show the corresponding placement square again
					if (placementSquares[i]) {
						placementSquares[i].visible = true;
					}
					break;
				}
			}
		}
		// Reset placement flags for all tower types when sold
		if (self.tower.id === 'poison') {
			poisonTowerPlaced = false;
		} else if (self.tower.id === 'slow') {
			slowTowerPlaced = false;
		} else if (self.tower.id === 'default') {
			defaultTowerPlaced = false;
		} else if (self.tower.id === 'rapid') {
			rapidTowerPlaced = false;
		} else if (self.tower.id === 'sniper') {
			sniperTowerPlaced = false;
		} else if (self.tower.id === 'splash') {
			splashTowerPlaced = false;
		}
		for (var i = 0; i < 2; i++) {
			for (var j = 0; j < 2; j++) {
				var cell = grid.getCell(gridX + i, gridY + j);
				if (cell) {
					// Only reset cell type if this wasn't a poison tower
					// Poison towers don't block movement so cells should already be type 0
					if (self.tower.id !== 'poison') {
						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);
		// Only invalidate pathfinding cache and recalculate for non-poison towers
		if (self.tower.id !== 'poison') {
			pathfindingCache = null;
			pathfindingCache = null; // Invalidate cache when towers are removed
			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;
		// --- FAKE PROGRESSION: Show visual damage progression, but keep actual stats fixed ---
		// Calculate fake visual damage based on level
		var visualDamage = self.tower.damage;
		if (self.tower.level > 1) {
			// Show 20% damage increase per level for visual feedback
			var damageMultiplier = 1 + (self.tower.level - 1) * 0.15;
			visualDamage = Math.floor(self.tower.damage * damageMultiplier);
		}
		statsText.setText('Level: ' + self.tower.level + '/' + self.tower.maxLevel + '\nDamage: ' + visualDamage + '\nFire Rate: ' + (60 / self.tower.fireRate).toFixed(1) + '/s');
		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("6 Kule Yerleştir", {
		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("6 Kule Yerleştir", {
		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) {
			// Check if minimum towers have been placed
			if (towersPlacedCount < minTowersRequired) {
				var notification = game.addChild(new Notification("Place " + minTowersRequired + " towers before starting! (" + towersPlacedCount + "/" + minTowersRequired + ")"));
				notification.x = 2048 / 2;
				notification.y = grid.height - 50;
				return;
			}
			//Play start button sound
			LK.getSound('button_start').play();
			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;
			// Make started image asset transparent using tween
			tween(startBlock, {
				alpha: 0
			}, {
				duration: 500,
				easing: tween.easeOut
			});
			// Hide tower placement frame when game starts
			if (self.placementFrame) {
				tween(self.placementFrame, {
					alpha: 0
				}, {
					duration: 500,
					easing: tween.easeOut,
					onFinish: function onFinish() {
						if (self.placementFrame && self.placementFrame.parent) {
							self.placementFrame.parent.removeChild(self.placementFrame);
						}
					}
				});
			}
			// Animate yellow frame to shrink to normal block size
			var normalBlockHeight = 70;
			var normalFrameHeight = normalBlockHeight + 32; // Add some padding around the normal block
			// Animate horizontal bars (top and bottom) height reduction
			tween(indicator, {
				height: 16
			}, {
				duration: 500,
				easing: tween.easeOut
			});
			tween(indicator2, {
				height: 16
			}, {
				duration: 500,
				easing: tween.easeOut
			});
			// Animate vertical bars (left and right) height reduction
			tween(leftWall, {
				height: normalFrameHeight
			}, {
				duration: 500,
				easing: tween.easeOut
			});
			tween(rightWall, {
				height: normalFrameHeight
			}, {
				duration: 500,
				easing: tween.easeOut
			});
			// Adjust position of horizontal bars to match new frame size
			tween(indicator, {
				y: -(normalFrameHeight / 2 - 8)
			}, {
				duration: 500,
				easing: tween.easeOut
			});
			tween(indicator2, {
				y: normalFrameHeight / 2 - 8
			}, {
				duration: 500,
				easing: tween.easeOut
			});
		}
	};
	var _loop2 = function _loop2() {
			marker = new Container();
			block = marker.attachAsset('notification', {
				anchorX: 0.5,
				anchorY: 0.5
			});
			block.width = blockWidth - 10;
			block.height = 70;
			// --- 25 Wave System ---
			waveNum = i + 1;
			waveType = "normal";
			enemyType = "normal";
			enemyCount = 8;
			isBossWave = waveNum % 10 === 0; // Define wave progression for 25 waves
			if (waveNum === 1) {
				block.tint = 0x0066FF;
				waveType = "beginning";
				enemyType = "blue";
				enemyCount = 4;
			} else if (waveNum === 2) {
				block.tint = 0xAA0000;
				waveType = "defance";
				enemyType = "immune";
				enemyCount = 4;
			} else if (waveNum === 3) {
				block.tint = 0xAAAAAA;
				waveType = "attack";
				enemyType = "normal";
				enemyCount = 4;
			} else if (waveNum === 4) {
				block.tint = 0xFFFF00;
				waveType = "mistakes";
				enemyType = "flying";
				enemyCount = 2;
			} else if (waveNum === 5) {
				block.tint = 0x00AAFF; // Blue color for fast enemies
				waveType = "greed";
				enemyType = "fast";
				enemyCount = 3; // 3 fast enemies, rat enemy spawned when for_the_fallen sound plays
			} else if (waveNum === 6) {
				block.tint = 0xFF00FF;
				waveType = "finale";
				enemyType = "swarm";
				enemyCount = 3;
			} else if (waveNum === 7) {
				block.tint = 0x8B4513;
				waveType = "the end";
				enemyType = "big";
				enemyCount = 1;
			} else if (waveNum >= 8 && waveNum <= 25) {
				// Generate varied waves for waves 8-25
				cyclePos = (waveNum - 8) % 7; // Cycle through 7 different types
				intensity = Math.floor((waveNum - 8) / 7) + 1; // Increase intensity every 7 waves
				switch (cyclePos) {
					case 0:
						// Immune waves
						block.tint = 0xAA0000;
						waveType = "Immune";
						enemyType = "immune";
						enemyCount = 3; // Changed from 4 to 3 for waves 8+
						break;
					case 1:
						// Fast waves
						block.tint = 0x00AAFF;
						waveType = "Fast";
						enemyType = "fast";
						enemyCount = 3; // Changed from 4 to 3 for waves 8+
						break;
					case 2:
						// Flying waves
						block.tint = 0xFFFF00;
						waveType = "Flying";
						enemyType = "flying";
						enemyCount = 3; // Changed from 4 to 3 for waves 8+
						break;
					case 3:
						// Swarm waves
						block.tint = 0xFF00FF;
						waveType = "Swarm";
						enemyType = "swarm";
						enemyCount = 3; // Changed from 4 to 3 for waves 8+
						break;
					case 4:
						// Normal waves (blue enemies only allowed in wave 1)
						block.tint = 0xAAAAAA;
						waveType = "Normal";
						enemyType = "normal";
						enemyCount = 3; // Changed from 4 to 3 for waves 8+
						break;
					case 5:
						// Rat waves
						block.tint = 0x8B4513;
						waveType = "Rat";
						enemyType = "rat";
						enemyCount = 2; // Rat waves have 2 enemies
						break;
					case 6:
						// Big boss waves (every 7th wave)
						block.tint = 0x8B4513;
						waveType = "Big Boss";
						enemyType = "big";
						enemyCount = 1; // Boss waves always have 1 enemy
						break;
				}
				// Special boss waves every 10 waves
				if (waveNum % 10 === 0) {
					block.tint = 0x8B4513;
					waveType = "Mega Boss";
					enemyType = "big";
					enemyCount = 1; // Boss waves always have 1 enemy
				}
			} else {
				// Fallback for any additional waves beyond 25
				block.tint = 0xAAAAAA;
				waveType = "Normal";
				enemyType = "normal";
				enemyCount = 4;
			}
			// --- End Extended 50 Wave System ---
			// Mark elite waves with a special visual indicator
			if (waveNum === 7 && enemyType !== 'swarm') {
				// Add a star indicator to the wave marker for elite waves
				eliteIndicator = marker.attachAsset('star_score', {
					anchorX: 0.5,
					anchorY: 0.5
				});
				eliteIndicator.width = 30;
				eliteIndicator.height = 30;
				eliteIndicator.tint = 0xFFD700; // Gold color
				eliteIndicator.y = -block.height / 2 - 15;
			}
			// Store the wave type and enemy count
			self.waveTypes[i] = enemyType;
			self.enemyCounts[i] = enemyCount;
			// Dalga tiplerini Türkçeye çevir
			function trWaveType(type) {
				var map = {
					"beginning": "Başlangıç",
					"defance": "Savunma",
					"attack": "Saldırı",
					"mistakes": "Hatalar",
					"greed": "Açgözlülük",
					"finale": "Final",
					"the end": "Son",
					"Immune": "Bağışık",
					"Fast": "Hızlı",
					"Flying": "Uçan",
					"Swarm": "Sürü",
					"Normal": "Normal",
					"Rat": "Sıçan",
					"Big Boss": "Büyük Patron",
					"Mega Boss": "Mega Patron",
					"big": "Büyük",
					"swarm": "Sürü",
					"immune": "Bağışık",
					"fast": "Hızlı",
					"flying": "Uçan",
					"normal": "Normal",
					"rat": "Sıçan"
				};
				return map[type] || type;
			}
			// Add shadow for wave type - 30% smaller than before
			waveTypeShadow = new Text2(trWaveType(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
			waveTypeText = new Text2(trWaveType(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
			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
			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);
		},
		marker,
		block,
		waveNum,
		waveType,
		enemyType,
		enemyCount,
		isBossWave,
		cyclePos,
		intensity,
		eliteIndicator,
		waveTypeShadow,
		waveTypeText,
		waveNumShadow,
		waveNum;
	for (var i = 0; i < totalWaves; i++) {
		_loop2();
	}
	// 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;
		}
		var baseCount = self.enemyCounts[waveNumber - 1];
		// Apply limits for waves 8 and above
		if (waveNumber === 8) {
			baseCount = 3; // Ensure exactly 3 enemies for wave 8 to match waves 9+
		} else if (waveNumber > 8) {
			var waveType = self.waveTypes[waveNumber - 1];
			if (waveType === 'big') {
				// Boss waves limited to 1
				baseCount = 1;
			} else {
				// All enemy types limited to 3 for waves 9+
				baseCount = Math.min(3, baseCount);
			}
		}
		return baseCount;
	};
	// 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 elite prefix for wave 7
		if (waveNumber === 7 && type !== 'swarm') {
			typeName = "Elite " + typeName;
		}
		return typeName;
	};
	self.positionIndicator = new Container();
	var indicator = self.positionIndicator.attachAsset('star_score', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	indicator.width = blockWidth - 10;
	indicator.height = 16;
	indicator.tint = 0xffad0e;
	indicator.y = -65;
	var indicator2 = self.positionIndicator.attachAsset('star_score', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	indicator2.width = blockWidth - 10;
	indicator2.height = 16;
	indicator2.tint = 0xffad0e;
	indicator2.y = 65;
	var leftWall = self.positionIndicator.attachAsset('star_score', {
		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('star_score', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	rightWall.width = 16;
	rightWall.height = 146;
	rightWall.tint = 0xffad0e;
	rightWall.x = (blockWidth - 16) / 2;
	// Create tower placement area frame (only visible before game starts)
	var placementFrame = new Container();
	placementFrame.x = grid.x;
	placementFrame.y = grid.y;
	// Create 6 placement squares in gridx11 area (column 11)
	var placementSquares = [];
	var _loop = function _loop() {
			square = placementFrame.attachAsset('placement_dot', {
				anchorX: 0.5,
				anchorY: 0.5
			});
			square.width = CELL_SIZE * 0.8;
			square.height = CELL_SIZE * 0.8;
			square.tint = 0x00FF00; // Green color
			square.alpha = 0.7; // Semi-transparent with better visibility
			square.x = 11 * CELL_SIZE + CELL_SIZE / 2; // Column 11, centered
			square.y = (6 + squareIndex * 5) * CELL_SIZE + CELL_SIZE / 2; // Spaced 5 cells apart vertically starting from row 6, centered
			// Add pulsating heart-like animation to make placement dots eye-catching
			function pulsatePlacementDot(dot, delay) {
				// Start with a small delay to stagger the animations
				tween({}, {}, {
					duration: delay,
					onFinish: function onFinish() {
						function heartBeat() {
							// First pulse - bigger scale
							tween(dot, {
								scaleX: 1.4,
								scaleY: 1.4,
								alpha: 0.9
							}, {
								duration: 300,
								easing: tween.easeOut,
								onFinish: function onFinish() {
									// Return to normal size
									tween(dot, {
										scaleX: 1.0,
										scaleY: 1.0,
										alpha: 0.7
									}, {
										duration: 200,
										easing: tween.easeIn,
										onFinish: function onFinish() {
											// Second pulse - smaller scale (like heartbeat)
											tween(dot, {
												scaleX: 1.2,
												scaleY: 1.2,
												alpha: 0.8
											}, {
												duration: 150,
												easing: tween.easeOut,
												onFinish: function onFinish() {
													// Return to normal again
													tween(dot, {
														scaleX: 1.0,
														scaleY: 1.0,
														alpha: 0.7
													}, {
														duration: 150,
														easing: tween.easeIn,
														onFinish: function onFinish() {
															// Wait before next heartbeat cycle
															tween({}, {}, {
																duration: 1200,
																onFinish: function onFinish() {
																	if (dot.parent && dot.visible) {
																		heartBeat(); // Continue pulsating if still visible
																	}
																}
															});
														}
													});
												}
											});
										}
									});
								}
							});
						}
						heartBeat(); // Start the pulsating animation
					}
				});
			}
			// Start pulsating animation for each placement square with staggered timing
			pulsatePlacementDot(square, squareIndex * 200); // 200ms delay between each dot
			placementSquares.push(square);
		},
		square;
	for (var squareIndex = 0; squareIndex < 6; squareIndex++) {
		_loop();
	}
	// Add placement frame to game
	game.addChild(placementFrame);
	// Store reference to hide it later
	self.placementFrame = placementFrame;
	self.addChild(self.positionIndicator);
	self.update = function () {
		// Update start button text based on tower count
		if (!self.gameStarted) {
			// Show different text based on tower count
			if (towersPlacedCount >= minTowersRequired) {
				startText.setText("başla");
				startTextShadow.setText("başla");
				startBlock.tint = 0x00AA00; // Green when ready
			} else {
				startText.setText("kule yerleştir");
				startTextShadow.setText("kule yerleştir");
				startBlock.tint = 0x888888; // Gray when not ready
			}
			startTextShadow.x = 4;
			startTextShadow.y = 4;
		}
		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];
			// Make all indicator blocks transparent
			tween(block, {
				alpha: 0.3
			}, {
				duration: 300,
				easing: tween.easeOut
			});
			if (i - 1 < currentWave) {
				block.alpha = .15; // Even more transparent for completed waves
			}
		}
		self.handleWaveProgression = function () {
			if (!self.gameStarted) {
				return;
			}
			// Check if black screen is active to prevent wave progression
			var isBlackScreenActive = fadeToBlackStarted && bossWaveCompleted && currentWave === 7;
			if (currentWave < totalWaves && !isBlackScreenActive) {
				waveTimer++;
				if (waveTimer >= nextWaveTime) {
					waveTimer = 0;
					currentWave++;
					waveInProgress = true;
					waveSpawned = false;
				}
			}
		};
		self.handleWaveProgression();
	};
	return self;
});

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

/**** 
* Game Code
****/ 
var activeTweens = [];
var maxActiveTweens = 15; // Further reduced maximum active tweens to improve performance
function _typeof(o) {
	"@babel/helpers - typeof";
	return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) {
		return typeof o;
	} : function (o) {
		return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
	}, _typeof(o);
}
var activeParticles = activeParticles || []; // Ensure activeParticles is defined
activeParticles = activeParticles.filter(function (particle) {
	return particle && particle.parent;
});
var SoundChainManager = {
	soundChains: {
		wave1Start: [{
			sound: 'war',
			delay: 0
		}, {
			sound: 'place',
			delay: 5000
		}, {
			sound: 'sevda',
			delay: 5000
		}, {
			sound: 'mov',
			delay: 5000
		}, {
			sound: 'og',
			delay: 5000
		}, {
			sound: 'miss',
			delay: 5000
		}],
		swarmBulletChain: [{
			sound: 'youcantstopus',
			delay: 0
		}, {
			sound: 'browser',
			delay: 2000
		}, {
			sound: 'tnk',
			delay: 5000
		}, {
			sound: 'borc',
			delay: 4000
		}, {
			sound: 'db',
			delay: 4000
		}],
		ratEntryChain: [{
			sound: 'wu',
			delay: 0
		}, {
			sound: 'bolt',
			delay: 3000
		}, {
			sound: 'hamburger',
			delay: 10000
		}, {
			sound: 'kola',
			delay: 10000
		}, {
			sound: 'hungry',
			delay: 10000
		}],
		flyingWave4Chain: [{
			sound: 'xr',
			delay: 0
		}, {
			sound: 'yar',
			delay: 4000
		}, {
			sound: 'upit',
			delay: 5000
		}, {
			sound: 'water',
			delay: 4000
		}, {
			sound: 'funny',
			delay: 5000
		}, {
			sound: 'z',
			delay: 5000
		}, {
			sound: 'sm',
			delay: 3000
		}],
		fexEnemyChain: [{
			sound: 'dog',
			delay: 0
		}, {
			sound: 'hav',
			delay: 22000
		}, {
			sound: 'ner',
			delay: 5000
		}, {
			sound: 'hv2',
			delay: 1000
		}, {
			sound: 'hv3',
			delay: 3000
		}, {
			sound: 'hv3',
			delay: 2000
		}, {
			sound: 'hv4',
			delay: 3000
		}, {
			sound: 'hlp',
			delay: 3000
		}],
		wave7BossChain: [{
			sound: 'we',
			delay: 0
		}, {
			sound: 'ek',
			delay: 2000
		}, {
			sound: 'tw',
			delay: 2000
		}, {
			sound: 'sh',
			delay: 15000
		}],
		fastEnemyWave5Chain: [{
			sound: 'fast_enemy_sound',
			delay: 0
		}, {
			sound: 'for_the_fallen',
			delay: 5000
		}]
	},
	activeChains: [],
	chainCooldowns: {},
	startSoundChain: function startSoundChain(chainName) {
		if (this.chainCooldowns[chainName] && LK.ticks - this.chainCooldowns[chainName] < 30000) {
			return;
		}
		this.chainCooldowns[chainName] = LK.ticks;
		var chain = {
			name: chainName,
			sounds: this.soundChains[chainName].slice(),
			currentIndex: 0,
			nextPlayTime: LK.ticks
		};
		this.activeChains.push(chain);
	},
	updateSoundChains: function updateSoundChains() {
		for (var i = this.activeChains.length - 1; i >= 0; i--) {
			var chain = this.activeChains[i];
			if (LK.ticks >= chain.nextPlayTime) {
				var soundData = chain.sounds[chain.currentIndex];
				LK.getSound(soundData.sound).play();
				this.handleChainSpecialActions(chain.name, chain.currentIndex);
				chain.currentIndex++;
				if (chain.currentIndex >= chain.sounds.length) {
					this.activeChains.splice(i, 1);
				} else {
					chain.nextPlayTime = LK.ticks + chain.sounds[chain.currentIndex].delay;
				}
			}
		}
	},
	handleChainSpecialActions: function handleChainSpecialActions(chainName, soundIndex) {
		if (chainName === 'flyingWave4Chain' && soundIndex === 6) {
			spawnFexEnemy();
		}
	}
};
SoundChainManager.updateSoundChains();
// --- FAKE PROGRESSION: TowerPreview always shows fixed stats, only level indicator is visual ---
// Translate tower upgrade notification messages
var upgradeNotificationMap = {
	"Cannot upgrade towers before game starts!": "Oyun başlamadan kuleler yükseltilemez!",
	"Not enough gold to upgrade!": "Yükseltmek için yeterli altın yok!",
	"Tower is already at max level!": "Kule zaten en yüksek seviyede!"
};
function translateUpgradeNotification(message) {
	return upgradeNotificationMap[message] || message;
}
var mainBackground = game.attachAsset('main_background', {
	anchorX: 0,
	anchorY: 0,
	x: 0,
	y: 0
});
var isHidingUpgradeMenu = 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 requestType = 'default'; // Define requestType variable to fix 'requestType is not defined' error
var pathId = 1;
var maxScore = 0;
var pathfindingCache = null;
var lastPathfindTime = 0;
var pathfindCacheTimeout = 1800; // Cache for 30 seconds (1800 ticks at 60fps)
var dynamicCacheTimeout = 1800; // Further reduced dynamic cache timeout for more frequent updates
var enemies = [];
var towers = [];
var bullets = [];
for (var i = 0; i < bullets.length; i++) {
	bullets[i].lastWasIntersecting = false;
}
var lastArrayCleanupTime = 0; // Track when we last cleaned up arrays
var arrayCleanupInterval = 360; // Clean up arrays every 6 seconds (360 frames at 60fps)
var defenses = [];
var selectedTower = null;
var gold = 183;
var lives = 20;
var score = 0;
var currentWave = 0;
var totalWaves = 25;
var waveTimer = 0;
var waveInProgress = false;
var waveSpawned = false;
var spawnInProgress = false; // Additional flag to prevent double spawning
var enemiesSpawnedThisWave = 0; // Counter to track spawned enemies per wave
var nextWaveTime = 12000 / 2;
var towersPlacedCount = 0; // Counter for placed towers
var minTowersRequired = 6; // Minimum towers required to start game
var placementNotification = null; // Notification for tower placement guidance
var sourceTower = null;
var enemiesToSpawn = 10; // Default number of enemies per wave
var poisonBulletHitCount = 0; // Counter for poison bullet hits
var gogogoSniperSoundPlayed = false; // Global flag to ensure gogogo sound only plays once for sniper bullets
var splashBulletSoundPlayed = false; // Global flag to ensure splash bullet sound only plays once ever
var defaultBulletHitCount = 0; // Counter for default bullet hits
var itDidntHurtSoundPlayed = false; // Global flag to ensure it didn't hurt sound only plays once ever
var youCantStopUsSoundPlayed = false; // Global flag to ensure you can't stop us sound only plays once ever
var weAreComingForYouSoundPlayed = false; // Global flag to ensure we are coming for you sound only plays once ever
var youWillNeverGiveUpSoundPlayed = false; // Global flag to ensure you will never give up sound only plays once ever
var godDayForDieSoundPlayed = false; // Global flag to ensure god day for die sound only plays once ever
var enemiesReachedGoalCount = 0; // Counter for enemies that reach the goal
var weWinSoundCooldown = 1200; // Cooldown period for wewin sound in milliseconds
var gidiklaniyorumSoundPlayed = false; // Global flag to ensure gidiklaniyorum sound only plays once ever
var beCarefulSoundPlayed = false; // Global flag to ensure becareful sound only plays once ever
var sniperBulletHitCount = 0; // Counter for sniper bullet hits
var sniperrSoundCooldown = 1200; // Cooldown period for sniperr sound in milliseconds
var keepMovingSoundCooldown = 1200; // Cooldown period for keepmoving sound in milliseconds
var poisonTowerPlaced = false; // Track if poison tower has been placed
var slowTowerPlaced = false; // Track if slow tower has been placed
var defaultTowerPlaced = false; // Track if default tower has been placed
var rapidTowerPlaced = false; // Track if rapid tower has been placed
var sniperTowerPlaced = false; // Track if sniper tower has been placed
var splashTowerPlaced = false; // Track if splash tower has been placed
var fastEnemySoundPlayed = false; // Track if fast enemy sound has been played this wave
var fastEnemySoundTimer = 0; // Timer for random fast enemy sound timing
var welcomeToHellSoundPlayed = false; // Global flag to ensure welcometohell sound only plays once ever
var bronzSoundPlayed = false; // Global flag to ensure bronz sound only plays once ever
var slowAreaEnemyCount = 0; // Counter for enemies entering slow tower area damage
var sunSoundCooldown = 2000; // Cooldown period for sun sound in milliseconds
var enemiesInSlowArea = []; // Track enemies currently in slow area
var wifiSoundCooldown = 2000; // Cooldown period for wifi sound in milliseconds
var taksiSoundCooldown = 2000; // Cooldown period for taksi sound in milliseconds
var vasiyetSoundPlayedThisWave = false; // Track if vasiyet sound has been played this wave for bagışıkdüşman hit by rapid bullets
var rapidBulletImmuneHitCount = 0; // Counter for rapid bullet hits on immune enemies
var gözlükSoundPlayedThisWave = false; // Track if gözlük sound has been played this wave for bagışıkdüşman hit by sniper bullets
var sniperBulletImmuneHitCount = 0; // Counter for sniper bullet hits on immune enemies
var slowBulletImmuneHitCount = 0; // Counter for slow bullet hits on immune enemies
var shySoundPlayedThisWave = false; // Track if shy sound has been played this wave for immune enemies hit by slow bullets
var browserSoundCooldown = 2000; // Cooldown period for browser sound in milliseconds
var warSoundPlayed = false; // Track if war sound has been played globally - only once per game
var mezarSoundPlayed = false; // Track if mezar sound has been played globally - only once per game
var weSoundPlayed = false; // Track if we sound has been played for wave 7 - only once per game
var wuSoundPlayed = false; // Track if wu sound has been played for rat enemies - only once per game
var işSoundPlayed = false; // Track if iş sound has been played after we sound - only once per game
var bossWaveCompleted = false; // Track if boss wave (wave 7) has been completed
var fadeToBlackStarted = false; // Track if fade to black has started
// Expanded object pools for various particle types
var poisonParticlePool = [];
var smokeParticlePool = [];
var fireParticlePool = [];
var poisonCloudPool = [];
var walkingFeetPool = [];
var animationObjectPool = []; // Pool for reusable animation objects
var maxPoolSize = 5; // Further reduced pool size from 30 to 5 to save memory
var maxAnimationPoolSize = 10; // Reduced animation object pool size
// Particle lifetime management system
var activeParticles = []; // Track all active particles for lifetime management
var maxActiveParticles = 60; // Increase maximum active particles to 60 to further reduce aggressiveness of particle cleanup
var maxParticleLifetime = 1000; // Maximum particle lifetime in milliseconds (1 second) - updated for proper visibility
var particleCleanupInterval = 120; // Cleanup particles every 120 frames (2 seconds) for optimal performance
var lastParticleCleanup = 0;
var wave1VexSpawned = false; // Track if vex enemy has been spawned in wave 1
var missSoundStarted = false; // Track if miss sound has started
var vexSpawnTimerStarted = false; // Track if vex spawn timer has started
var vexSpawnTimer = 0; // Timer for vex spawn after miss sound
var nSoundFinished = false; // Track if 'n' sound has finished playing
// Sound pooling system
var soundPool = {};
var maxSoundInstances = 10; // Maximum instances per sound type
var soundCleanupInterval = 600; // Change sound cleanup interval to every 10 seconds (600 frames at 60fps)
var lastSoundCleanup = 0;
var activeSounds = []; // Track currently playing sounds
var maxActiveSounds = 70; // Change maximum active sounds to 70 for better sound performance
// Spatial partitioning for optimized enemy targeting
var spatialGrid = {
	cellSize: CELL_SIZE * 2,
	// Each spatial cell covers 2x2 game cells
	width: 12,
	// 24 / 2
	height: 18,
	// 36 / 2  
	cells: [],
	init: function init() {
		this.cells = [];
		for (var x = 0; x < this.width; x++) {
			this.cells[x] = [];
			for (var y = 0; y < this.height; y++) {
				this.cells[x][y] = [];
			}
		}
	},
	clear: function clear() {
		for (var x = 0; x < this.width; x++) {
			for (var y = 0; y < this.height; y++) {
				this.cells[x][y].length = 0;
			}
		}
	},
	addEnemy: function addEnemy(enemy) {
		var gridX = Math.floor(enemy.x / this.cellSize);
		var gridY = Math.floor(enemy.y / this.cellSize);
		if (gridX >= 0 && gridX < this.width && gridY >= 0 && gridY < this.height) {
			this.cells[gridX][gridY].push(enemy);
		}
	},
	getEnemiesInRange: function getEnemiesInRange(x, y, range) {
		var enemies = [];
		var cellSize = this.cellSize; // Cache cellSize
		var startX = Math.max(0, Math.floor((x - range) / cellSize));
		var endX = Math.min(this.width - 1, Math.floor((x + range) / cellSize));
		var startY = Math.max(0, Math.floor((y - range) / cellSize));
		var endY = Math.min(this.height - 1, Math.floor((y + range) / cellSize));
		for (var gx = startX; gx <= endX; gx++) {
			for (var gy = startY; gy <= endY; gy++) {
				var cellEnemies = this.cells[gx][gy];
				// Use direct array concatenation for better performance
				if (cellEnemies.length > 0) {
					enemies = enemies.concat(cellEnemies);
				}
			}
		}
		return enemies;
	}
};
spatialGrid.init();
function getPoisonParticle() {
	if (poisonParticlePool.length > 0) {
		var particle = poisonParticlePool.pop();
		// Reset lifetime tracking for reused particles
		particle.creationTime = LK.ticks;
		particle.maxLifetime = maxParticleLifetime;
		return particle;
	}
	var poisonParticle = new Container();
	var poisonGraphics = poisonParticle.attachAsset('rangeCircle', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	poisonParticle.poisonGraphics = poisonGraphics;
	poisonParticle.particleType = 'poison';
	poisonParticle.creationTime = LK.ticks;
	poisonParticle.maxLifetime = maxParticleLifetime;
	activeParticles.push(poisonParticle);
	return poisonParticle;
}
function getSmokeParticle() {
	// Simplified pool overflow check - only when significantly over limit
	if (smokeParticlePool.length > maxPoolSize * 1.5) {
		// Quick cleanup of excess particles
		var excessCount = smokeParticlePool.length - maxPoolSize;
		for (var i = 0; i < excessCount; i++) {
			var excessParticle = smokeParticlePool.pop();
			if (excessParticle && excessParticle.destroy) {
				excessParticle.destroy();
			}
		}
	}
	if (smokeParticlePool.length > 0) {
		var particle = smokeParticlePool.pop();
		// Reset lifetime tracking for reused particles
		particle.creationTime = LK.ticks;
		particle.maxLifetime = maxParticleLifetime;
		return particle;
	}
	// Check if we're creating too many particles overall
	if (activeParticles.length >= maxActiveParticles) {
		// Force cleanup oldest particles before creating new ones
		for (var i = 0; i < 5; i++) {
			if (activeParticles.length > 0) {
				var oldestParticle = activeParticles.shift();
				if (oldestParticle && oldestParticle.parent) {
					oldestParticle.parent.removeChild(oldestParticle);
				}
				if (oldestParticle && oldestParticle.destroy) {
					oldestParticle.destroy();
				}
			}
		}
	}
	var smokeParticle = new Container();
	var smokeGraphics = smokeParticle.attachAsset('rangeCircle', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	smokeParticle.smokeGraphics = smokeGraphics;
	smokeParticle.particleType = 'smoke';
	smokeParticle.creationTime = LK.ticks;
	smokeParticle.maxLifetime = maxParticleLifetime;
	activeParticles.push(smokeParticle);
	return smokeParticle;
}
function getFireParticle() {
	// Simplified pool overflow check - only when significantly over limit
	if (fireParticlePool.length > maxPoolSize * 1.5) {
		// Quick cleanup of excess particles
		var excessCount = fireParticlePool.length - maxPoolSize;
		for (var i = 0; i < excessCount; i++) {
			var excessParticle = fireParticlePool.pop();
			if (excessParticle && excessParticle.destroy) {
				excessParticle.destroy();
			}
		}
	}
	if (fireParticlePool.length > 0) {
		var particle = fireParticlePool.pop();
		// Reset lifetime tracking for reused particles
		particle.creationTime = LK.ticks;
		particle.maxLifetime = maxParticleLifetime;
		return particle;
	}
	// Check if we're creating too many particles overall
	if (activeParticles.length >= maxActiveParticles) {
		// Force cleanup oldest particles before creating new ones
		for (var i = 0; i < 5; i++) {
			if (activeParticles.length > 0) {
				var oldestParticle = activeParticles.shift();
				if (oldestParticle && oldestParticle.parent) {
					oldestParticle.parent.removeChild(oldestParticle);
				}
				if (oldestParticle && oldestParticle.destroy) {
					oldestParticle.destroy();
				}
			}
		}
	}
	var fireParticle = new Container();
	var fireGraphics = fireParticle.attachAsset('rangeCircle', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	fireParticle.fireGraphics = fireGraphics;
	fireParticle.particleType = 'fire';
	fireParticle.creationTime = LK.ticks;
	fireParticle.maxLifetime = maxParticleLifetime;
	activeParticles.push(fireParticle);
	return fireParticle;
}
function getPoisonCloudParticle() {
	// Simplified pool overflow check - only when significantly over limit
	if (poisonCloudPool.length > maxPoolSize * 1.5) {
		// Quick cleanup of excess particles
		var excessCount = poisonCloudPool.length - maxPoolSize;
		for (var i = 0; i < excessCount; i++) {
			var excessParticle = poisonCloudPool.pop();
			if (excessParticle && excessParticle.destroy) {
				excessParticle.destroy();
			}
		}
	}
	if (poisonCloudPool.length > 0) {
		var particle = poisonCloudPool.pop();
		// Reset lifetime tracking for reused particles
		particle.creationTime = LK.ticks;
		particle.maxLifetime = maxParticleLifetime;
		return particle;
	}
	// Check if we're creating too many particles overall
	if (activeParticles.length >= maxActiveParticles) {
		// Force cleanup oldest particles before creating new ones
		for (var i = 0; i < 5; i++) {
			if (activeParticles.length > 0) {
				var oldestParticle = activeParticles.shift();
				if (oldestParticle && oldestParticle.parent) {
					oldestParticle.parent.removeChild(oldestParticle);
				}
				if (oldestParticle && oldestParticle.destroy) {
					oldestParticle.destroy();
				}
			}
		}
	}
	var poisonCloud = new Container();
	var cloudGraphics = poisonCloud.attachAsset('rangeCircle', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	poisonCloud.cloudGraphics = cloudGraphics;
	poisonCloud.particleType = 'poisonCloud';
	poisonCloud.creationTime = LK.ticks;
	poisonCloud.maxLifetime = maxParticleLifetime;
	activeParticles.push(poisonCloud);
	return poisonCloud;
}
function getWalkingFeetParticle() {
	if (walkingFeetPool.length > 0) {
		var particle = walkingFeetPool.pop();
		// Reset lifetime tracking for reused particles
		particle.creationTime = LK.ticks;
		particle.maxLifetime = maxParticleLifetime * 10; // Walking feet particles live longer
		return particle;
	}
	var walkingFeet = new Container();
	var feetGraphics = walkingFeet.attachAsset('walkingFeet', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	walkingFeet.feetGraphics = feetGraphics;
	walkingFeet.particleType = 'walkingFeet';
	walkingFeet.creationTime = LK.ticks;
	walkingFeet.maxLifetime = maxParticleLifetime * 10; // Walking feet particles live longer
	activeParticles.push(walkingFeet);
	return walkingFeet;
}
function getAnimationObject() {
	if (animationObjectPool.length > 0) {
		var animObj = animationObjectPool.pop();
		// Reset animation object properties
		animObj.isActive = false;
		animObj.target = null;
		animObj.properties = {};
		animObj.config = {};
		animObj.startTime = 0;
		return animObj;
	}
	// Create new animation object if pool is empty
	var animationObject = {
		isActive: false,
		target: null,
		properties: {},
		config: {},
		startTime: 0,
		currentValues: {},
		initialValues: {}
	};
	return animationObject;
}
function returnAnimationObject(animObj) {
	if (!animObj) return;
	// Stop any active tweens
	if (animObj.target && animObj.isActive) {
		tween.stop(animObj.target, animObj.properties);
	}
	// Simplified reset - only essential properties
	animObj.isActive = false;
	animObj.target = null;
	animObj.startTime = 0;
	// Return to pool if not at capacity
	if (animationObjectPool.length < maxAnimationPoolSize) {
		animationObjectPool.push(animObj);
	}
}
function createPooledAnimation(target, properties, config) {
	if (!target || _typeof(properties) !== 'object') return null;
	var animObj = getAnimationObject();
	animObj.target = target;
	animObj.properties = Object.assign({}, properties);
	animObj.config = Object.assign({}, config);
	animObj.isActive = true;
	animObj.startTime = LK.ticks;
	// Store initial values
	for (var prop in properties) {
		animObj.initialValues[prop] = target[prop] || 0;
		animObj.currentValues[prop] = animObj.initialValues[prop];
	}
	// Create the actual tween with cleanup callback
	var originalOnFinish = config.onFinish;
	config.onFinish = function () {
		if (originalOnFinish) originalOnFinish();
		returnAnimationObject(animObj);
	};
	tween(target, properties, config);
	return animObj;
}
// returnParticle function removed - all particle management now handled by periodic cleanup systems
// Sound pool management functions with stricter limits
function getPooledSound(soundId) {
	// Initialize pool for this sound type if it doesn't exist
	if (!soundPool[soundId]) {
		soundPool[soundId] = {
			available: [],
			active: [],
			createdCount: 0
		};
	}
	var pool = soundPool[soundId];
	var sound;
	// Try to reuse an available sound instance
	if (pool.available.length > 0) {
		sound = pool.available.pop();
		// Reset sound properties if needed
		if (sound.stop) {
			sound.stop();
		}
	} else if (pool.createdCount < maxSoundInstances) {
		// Create new sound instance if under limit
		sound = LK.getSound(soundId);
		pool.createdCount++;
		// Wrap the original play method to track usage
		var originalPlay = sound.play;
		sound.play = function () {
			// Move to active list
			var availableIndex = pool.available.indexOf(sound);
			if (availableIndex !== -1) {
				pool.available.splice(availableIndex, 1);
			}
			if (pool.active.indexOf(sound) === -1) {
				pool.active.push(sound);
			}
			// Track globally for cleanup
			sound.lastPlayTime = LK.ticks;
			sound.isPlaying = true;
			if (activeSounds.indexOf(sound) === -1) {
				activeSounds.push(sound);
			}
			return originalPlay.call(this);
		};
	} else {
		// Pool limit reached, force cleanup oldest sound and reuse
		if (pool.active.length > 0) {
			sound = pool.active[0];
			// Force stop and clear audio buffer references
			forceCleanupSound(sound);
			// Remove from active list
			pool.active.splice(0, 1);
		} else if (pool.available.length > 0) {
			sound = pool.available.pop();
			// Force cleanup of unused instance
			forceCleanupSound(sound);
		} else {
			// Last resort: create temporary sound (will be cleaned up aggressively)
			sound = LK.getSound(soundId);
		}
	}
	return sound;
}
function forceCleanupSound(sound) {
	// Extremely conservative - only cleanup if sound has been idle for very long periods
	if (sound && sound.lastPlayTime && LK.ticks - sound.lastPlayTime < 1800) {
		// Sound played recently, skip cleanup entirely (increased from 600 to 1800 - 30 seconds)
		return;
	}
	// Very gentle stop the sound only if it exists and supports stop
	if (sound && sound.stop) {
		try {
			sound.stop();
		} catch (e) {
			// Ignore errors if sound is already stopped
		}
	}
	// Only clear references if sound has been idle for extremely long time
	if (sound && (!sound.lastPlayTime || LK.ticks - sound.lastPlayTime > 3600)) {
		sound.isPlaying = false;
		sound.lastPlayTime = 0;
		// Only clear internal references for very idle sounds (much increased threshold)
		if (sound._source) {
			sound._source = null;
		}
		// Keep _buffer reference for potential reuse unless extremely old
		if (sound.lastPlayTime && LK.ticks - sound.lastPlayTime > 21600) {
			if (sound._buffer) {
				sound._buffer = null;
			}
		}
		if (sound.source) {
			sound.source = null;
		}
		// Only close audio context for extremely old sounds to prevent audio issues
		if (sound.context && sound.lastPlayTime && LK.ticks - sound.lastPlayTime > 54000) {
			try {
				sound.context.close();
				sound.context = null;
			} catch (e) {
				// Ignore context close errors
			}
		}
	}
}
function returnSoundToPool(sound, soundId) {
	if (!soundPool[soundId]) return;
	var pool = soundPool[soundId];
	// Remove from active list - let periodic cleanup handle all sound management
	var activeIndex = pool.active.indexOf(sound);
	if (activeIndex !== -1) {
		pool.active.splice(activeIndex, 1);
	}
	// Add to available list with stricter size limit - no manual cleanup
	var maxAvailable = Math.floor(maxSoundInstances / 3); // Reduced from /2 to /3
	if (pool.available.indexOf(sound) === -1 && pool.available.length < maxAvailable) {
		pool.available.push(sound);
	}
}
function cleanupIdleSounds() {
	// Split cleanup into groups with frame delays to prevent performance spikes
	var soundIds = Object.keys(soundPool);
	var groupSize = 3; // Process 3 sound pools at a time
	var currentGroup = Math.floor(LK.ticks / 2) % Math.ceil(soundIds.length / groupSize); // Switch groups every 2 frames
	var startIndex = currentGroup * groupSize;
	var endIndex = Math.min(startIndex + groupSize, soundIds.length);
	// Only process sounds in current group
	for (var idx = startIndex; idx < endIndex; idx++) {
		var soundId = soundIds[idx];
		var pool = soundPool[soundId];
		// Handle all sound state management that was previously done in returnSoundToPool
		// Reduce available pool size to 1/4 of max instances
		var maxAvailable = Math.floor(maxSoundInstances / 4);
		while (pool.available.length > maxAvailable) {
			var excessSound = pool.available.pop();
			forceCleanupSound(excessSound);
			pool.createdCount = Math.max(0, pool.createdCount - 1);
		}
		// Force cleanup active sounds if too many
		var maxActive = Math.floor(maxSoundInstances / 2);
		while (pool.active.length > maxActive) {
			var excessActiveSound = pool.active.shift();
			forceCleanupSound(excessActiveSound);
		}
		// Handle automatic sound lifecycle management that returnSoundToPool was doing manually
		// Move finished sounds from active to available pools automatically
		for (var i = pool.active.length - 1; i >= 0; i--) {
			var activeSound = pool.active[i];
			if (activeSound && !activeSound.isPlaying && activeSound.lastPlayTime && LK.ticks - activeSound.lastPlayTime > 60) {
				// Sound finished playing, move to available pool automatically
				pool.active.splice(i, 1);
				if (pool.available.length < maxAvailable) {
					pool.available.push(activeSound);
				}
			}
		}
	}
}
// Comprehensive wave cleanup function to prevent memory leaks and performance issues
// Override LK.getSound to use pooled sounds for performance-critical sounds
var originalLKGetSound = LK.getSound;
LK.getSound = function (soundId) {
	// List of sounds that benefit from pooling (frequently played sounds)
	var pooledSounds = ['walking', 'tower_shoot', 'footstep', 'egzos', 'flame_sound', 'poison_bullet_hit', 'bullet_casing_drop', 'bird_chirp'];
	if (pooledSounds.indexOf(soundId) !== -1) {
		return getPooledSound(soundId);
	} else {
		// Use original method for less frequently played sounds
		return originalLKGetSound.call(this, soundId);
	}
};
// Create gold display container with background image and text
var goldDisplay = new Container();
var goldBackground = goldDisplay.attachAsset('coin_gold', {
	anchorX: 0.5,
	anchorY: 0.5,
	width: 90,
	height: 90
});
goldBackground.x = 0; // Position background behind the text
var goldText = new Text2(gold.toString(), {
	size: 28,
	fill: 0x000000,
	weight: 800
});
goldText.anchor.set(0.5, 0.5);
goldText.x = 0; // Position text on top of background
goldDisplay.addChild(goldText);
// Create lives display container with background image and text
var livesDisplay = new Container();
var livesBackground = livesDisplay.attachAsset('heart_life', {
	anchorX: 0.5,
	anchorY: 0.5,
	width: 90,
	height: 90
});
livesBackground.x = 0; // Position background behind the text
var livesText = new Text2(lives.toString(), {
	size: 28,
	fill: 0x000000,
	weight: 800
});
livesText.anchor.set(0.5, 0.5);
livesText.x = 0; // Position text on top of background
livesDisplay.addChild(livesText);
// Create score display container with image and text
var scoreDisplay = new Container();
var scoreIcon = scoreDisplay.attachAsset('score_icon', {
	anchorX: 0.5,
	anchorY: 0.5,
	width: 90,
	height: 90
});
scoreIcon.x = -45; // Position icon to the left
var scoreText = new Text2(score.toString(), {
	size: 28,
	fill: 0xFFFFFF,
	weight: 800
});
scoreText.anchor.set(0.5, 0.5);
scoreText.x = -45; // Position text on top of icon
scoreDisplay.addChild(scoreText);
// Add ask image asset at top layer with 100x100 size
var askDisplay = game.attachAsset('ask', {
	anchorX: 0.5,
	anchorY: 0.5,
	width: 100,
	height: 100
});
// Position ask display at bottom-left above rapid tower
askDisplay.x = 470; // Moved slightly more to the right
askDisplay.y = 2732 - 600; // Moved even higher up above rapid tower area
// Add mary image asset positioned at bottom of ask asset
var maryDisplay = game.attachAsset('mary', {
	anchorX: 0.5,
	anchorY: 0.5,
	width: 200,
	height: 160
});
// Position mary at bottom of ask asset
maryDisplay.x = askDisplay.x + 70; // Moved slightly more to the right
maryDisplay.y = askDisplay.y + 150; // Moved slightly down
// Initially hide mary - will be shown when wave 8 starts
maryDisplay.visible = false;
// Add bird image asset positioned above ask asset
var birdDisplay = game.attachAsset('bird', {
	anchorX: 0.5,
	anchorY: 0.5,
	width: 100,
	height: 100
});
// Position bird slightly above ask asset
birdDisplay.x = askDisplay.x;
birdDisplay.y = askDisplay.y - 120; // Positioned above ask asset
// Add bird sound functionality - play chirp sound every 8-12 seconds
var birdSoundTimer = 0;
var nextBirdSoundTime = 480 + Math.random() * 240; // 8-12 seconds at 60fps
birdDisplay.update = function () {
	// Check if black screen is active - only for wave 7
	var isBlackScreenActive = fadeToBlackStarted && bossWaveCompleted && currentWave === 7;
	if (!isBlackScreenActive) {
		birdSoundTimer++;
		if (birdSoundTimer >= nextBirdSoundTime) {
			LK.getSound('bird_chirp').play();
			birdSoundTimer = 0;
			nextBirdSoundTime = 480 + Math.random() * 240; // Reset timer for next chirp
		}
	}
};
// Make birdDisplay interactive to play sound on click
birdDisplay.down = function () {
	LK.getSound('bird_chirp').play();
};
// Add bird to game update so its update method gets called
game.addChild(birdDisplay);
// Add tabela display in right middle edge area
var tabelaDisplay = game.attachAsset('tabela', {
	anchorX: 0.5,
	anchorY: 0.5,
	width: 160,
	height: 160
});
// Position tabela one cell down and one cell left from previous position
tabelaDisplay.x = 2048 - 360 - 76; // Move one cell left (76px)
tabelaDisplay.y = 2732 / 2 + 76 - 650; // Move one cell down (76px) then 650px up
// Add displays directly to game object instead of LK.gui for better visibility
game.addChild(goldDisplay);
game.addChild(livesDisplay);
game.addChild(scoreDisplay);
game.addChild(tabelaDisplay);
// Add mary display last so it appears on top of other elements
game.addChild(maryDisplay);
// Add update method to mary to check wave progression
maryDisplay.update = function () {
	// Show mary starting from wave 8
	if (currentWave >= 8) {
		maryDisplay.visible = true;
	}
};
// Position displays in the top-right corner with absolute coordinates
var topMargin = 65; // Moved up slightly more
var spacing = 190; // Equalized spacing between displays
var rightOffset = 1520; // Moved slightly to the left
goldDisplay.x = rightOffset + 30;
goldDisplay.y = topMargin;
livesDisplay.x = rightOffset + spacing;
livesDisplay.y = topMargin;
scoreDisplay.x = rightOffset + spacing * 2 + 50;
scoreDisplay.y = topMargin;
function updateUI() {
	goldText.setText(gold.toString());
	livesText.setText(lives.toString());
	scoreText.setText(score.toString());
}
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); // Grid cells hidden from visual display
// game.addChild(debugLayer); // Debug layer hidden
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, towerType) {
	// Define the exact placement squares where towers can be placed
	var allowedPlacements = [{
		x: 11,
		y: 6
	},
	// First placement square
	{
		x: 11,
		y: 11
	},
	// Second placement square  
	{
		x: 11,
		y: 16
	},
	// Third placement square
	{
		x: 11,
		y: 21
	},
	// Fourth placement square
	{
		x: 11,
		y: 26
	},
	// Fifth placement square
	{
		x: 11,
		y: 31
	} // Sixth placement square
	];
	// Check if current grid position matches any allowed placement
	var isAllowedPlacement = false;
	for (var p = 0; p < allowedPlacements.length; p++) {
		var placement = allowedPlacements[p];
		if (gridX === placement.x && gridY === placement.y) {
			isAllowedPlacement = true;
			break;
		}
	}
	// Block placement if not in allowed positions
	if (!isAllowedPlacement) {
		return true; // Block placement outside allowed squares
	}
	// Poison towers never block paths since enemies can pass through them
	if (towerType === 'poison') {
		return false;
	}
	// In single column formation, only check vertically adjacent towers
	for (var checkY = gridY - 2; checkY <= gridY + 3; checkY++) {
		// Skip the cells that would be occupied by the new tower
		if (checkY >= gridY && checkY < gridY + 2) {
			continue;
		}
		// Only check within the center column (gridX 11-12)
		for (var checkX = gridX; checkX < gridX + 2; checkX++) {
			var checkCell = grid.getCell(checkX, checkY);
			if (checkCell && checkCell.type === 1) {
				// Found a vertically adjacent tower in same column, prevent placement
				return true;
			}
		}
	}
	var cells = [];
	for (var i = 0; i < 2; i++) {
		for (var j = 0; j < 2; j++) {
			var cell = grid.getCell(gridX + i, gridY + j);
			if (cell) {
				cells.push({
					cell: cell,
					originalType: cell.type
				});
				cell.type = 1;
			}
		}
	}
	var blocked = grid.pathFind();
	for (var i = 0; i < cells.length; i++) {
		cells[i].cell.type = cells[i].originalType;
	}
	grid.pathFind();
	grid.renderDebug();
	return blocked;
}
function getTowerCost(towerType) {
	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 totalValue;
}
function canPlaceTowerType(towerType) {
	switch (towerType) {
		case 'poison':
			return !poisonTowerPlaced;
		case 'slow':
			return !slowTowerPlaced;
		case 'default':
			return !defaultTowerPlaced;
		case 'rapid':
			return !rapidTowerPlaced;
		case 'sniper':
			return !sniperTowerPlaced;
		case 'splash':
			return !splashTowerPlaced;
		default:
			return false;
		// No unknown tower types allowed
	}
}
function placeTower(gridX, gridY, towerType) {
	var towerCost = getTowerCost(towerType);
	if (!canPlaceTowerType(towerType)) {
		var notification = game.addChild(new Notification(towerType.charAt(0).toUpperCase() + towerType.slice(1) + " tower can only be placed once!"));
		notification.x = 2048 / 2;
		notification.y = grid.height - 50;
		return false;
	}
	if (gold >= towerCost) {
		var tower = new Tower(towerType || 'default');
		tower.placeOnGrid(gridX, gridY);
		towerLayer.addChild(tower);
		towers.push(tower);
		setGold(gold - towerCost);
		// Increment tower placement counter
		towersPlacedCount++;
		// Track placement of all tower types
		if (towerType === 'poison') {
			poisonTowerPlaced = true;
		} else if (towerType === 'slow') {
			slowTowerPlaced = true;
		} else if (towerType === 'default') {
			defaultTowerPlaced = true;
		} else if (towerType === 'rapid') {
			rapidTowerPlaced = true;
		} else if (towerType === 'sniper') {
			sniperTowerPlaced = true;
		} else if (towerType === 'splash') {
			splashTowerPlaced = true;
		}
		// Reset tower preview and dragging state
		towerPreview.visible = false;
		isDragging = false;
		//Play tower placement sound - special sounds for poison, splash and sniper towers
		if (towerType === 'poison') {
			LK.getSound('poison_impact').play();
		} else if (towerType === 'splash') {
			LK.getSound('splash_place').play();
		} else if (towerType === 'sniper') {
			LK.getSound('yessir').play();
		} else if (towerType !== 'default') {
			// Play placement sound for all tower types except default
			LK.getSound('tower_place').play();
		}
		pathfindingCache = null; // Invalidate cache when towers are placed
		grid.pathFind();
		grid.renderDebug();
		// Hide placement notification after placing the first tower
		if (towersPlacedCount === 1 && placementNotification) {
			placementNotification.destroy();
			placementNotification = null;
		}
		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) {
	// Handle vex mercy message and tower animation cleanup on touch
	if (window.vexAnimationActive && (window.vexMercyText || window.vexAnimatedTower)) {
		// Stop the animation
		window.vexAnimationActive = false;
		// Hide and remove mercy text immediately
		if (window.vexMercyText && window.vexMercyText.parent) {
			tween.stop(window.vexMercyText, {
				alpha: true
			});
			tween(window.vexMercyText, {
				alpha: 0
			}, {
				duration: 300,
				easing: tween.easeOut,
				onFinish: function onFinish() {
					if (window.vexMercyText && window.vexMercyText.parent) {
						window.vexMercyText.parent.removeChild(window.vexMercyText);
					}
					window.vexMercyText = null;
				}
			});
		}
		// Stop tower animation and return to normal size
		if (window.vexAnimatedTower && window.vexAnimatedTower.parent) {
			tween.stop(window.vexAnimatedTower, {
				scaleX: true,
				scaleY: true
			});
			tween(window.vexAnimatedTower, {
				scaleX: 1.0,
				scaleY: 1.0
			}, {
				duration: 300,
				easing: tween.easeOut,
				onFinish: function onFinish() {
					window.vexAnimatedTower = null;
				}
			});
		}
	}
	// Clean up any orphaned event listeners
	if (LK.ticks % 600 === 0) {
		// Every 10 seconds
		// Force cleanup of objects without parents
		for (var i = game.children.length - 1; i >= 0; i--) {
			var child = game.children[i];
			if (child && typeof child.down === 'function' && !child.parent) {
				// Remove orphaned child with event listeners
				game.removeChild(child);
			}
		}
	}
	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];
		// Check if this tower type can be placed before allowing drag
		var canAfford = gold >= getTowerCost(tower.towerType);
		var canPlace = canPlaceTowerType(tower.towerType);
		// Only allow dragging if tower can be afforded and placed
		if (!canAfford || !canPlace) {
			continue; // Skip this tower - cannot be dragged
		}
		// Increase touch sensitivity by expanding the touch area significantly
		var touchPadding = 80; // Increase touch area by 80 pixels on each side
		var touchWidth = tower.width + touchPadding * 2;
		var touchHeight = tower.height + touchPadding * 2;
		if (x >= tower.x - touchWidth / 2 && x <= tower.x + touchWidth / 2 && y >= tower.y - touchHeight / 2 && y <= tower.y + touchHeight / 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 && towerPreview.visible) {
		// Check if the tower type can still be placed during drag
		var canAfford = gold >= getTowerCost(towerPreview.towerType);
		var canPlace = canPlaceTowerType(towerPreview.towerType);
		if (!canAfford || !canPlace) {
			// Tower can no longer be placed, stop dragging
			isDragging = false;
			towerPreview.visible = false;
			return;
		}
		// 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;
		towerPreview.visible = false; // Ensure tower preview is hidden when dragging ends
		// Snap to nearest valid placement square
		var allowedPlacements = [{
			x: 11,
			y: 6
		},
		// First placement square
		{
			x: 11,
			y: 11
		},
		// Second placement square  
		{
			x: 11,
			y: 16
		},
		// Third placement square
		{
			x: 11,
			y: 21
		},
		// Fourth placement square
		{
			x: 11,
			y: 26
		},
		// Fifth placement square
		{
			x: 11,
			y: 31
		} // Sixth placement square
		];
		// Find the nearest valid placement square
		var nearestSquare = null;
		var nearestDistance = Infinity;
		var dropX = x;
		var dropY = y - CELL_SIZE * 1.5; // Account for the offset used during dragging
		for (var p = 0; p < allowedPlacements.length; p++) {
			var placement = allowedPlacements[p];
			var squareWorldX = grid.x + placement.x * CELL_SIZE + CELL_SIZE;
			var squareWorldY = grid.y + placement.y * CELL_SIZE + CELL_SIZE;
			var dx = dropX - squareWorldX;
			var dy = dropY - squareWorldY;
			var distance = Math.sqrt(dx * dx + dy * dy);
			if (distance < nearestDistance) {
				nearestDistance = distance;
				nearestSquare = placement;
			}
		}
		// Snap to the nearest square if within reasonable range (2 grid cells)
		if (nearestSquare && nearestDistance < CELL_SIZE * 2) {
			towerPreview.gridX = nearestSquare.x;
			towerPreview.gridY = nearestSquare.y;
			towerPreview.x = grid.x + nearestSquare.x * CELL_SIZE + CELL_SIZE / 2;
			towerPreview.y = grid.y + nearestSquare.y * CELL_SIZE + CELL_SIZE / 2;
			towerPreview.checkPlacement();
		}
		if (towerPreview.canPlace) {
			var blockResult = wouldBlockPath(towerPreview.gridX, towerPreview.gridY, towerPreview.towerType);
			if (!blockResult) {
				placeTower(towerPreview.gridX, towerPreview.gridY, towerPreview.towerType);
			} else {
				// Check if blocking is due to adjacent towers
				var hasAdjacentTower = false;
				for (var checkX = towerPreview.gridX - 2; checkX <= towerPreview.gridX + 3; checkX++) {
					for (var checkY = towerPreview.gridY - 2; checkY <= towerPreview.gridY + 3; checkY++) {
						// Skip the cells that would be occupied by the new tower
						if (checkX >= towerPreview.gridX && checkX < towerPreview.gridX + 2 && checkY >= towerPreview.gridY && checkY < towerPreview.gridY + 2) {
							continue;
						}
						var checkCell = grid.getCell(checkX, checkY);
						if (checkCell && checkCell.type === 1) {
							hasAdjacentTower = true;
							break;
						}
					}
					if (hasAdjacentTower) break;
				}
				var notificationText = hasAdjacentTower ? "Cannot place towers next to each other!" : "Tower would block the path!";
				var notification = game.addChild(new Notification(notificationText));
				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();
			}
		}
	}
};
var waveIndicator = new WaveIndicator();
waveIndicator.x = 2048 / 2;
waveIndicator.y = 2732 - 80;
game.addChild(waveIndicator);
// Show placement notification function
function showPlacementNotification() {
	if (!placementNotification) {
		placementNotification = new Notification("Place the towers on the green spots.");
		placementNotification.x = 2048 / 2;
		placementNotification.y = 2732 / 2; // Position at center of screen
		game.addChild(placementNotification);
		// Make notification persistent by overriding its update method
		placementNotification.update = function () {
			// Only hide notification after second tower is placed
			if (towersPlacedCount >= 2) {
				this.destroy();
				placementNotification = null;
			}
		};
	}
}
// Automatically place default tower at enemy spawn point nokta1 (first allowed placement position)
var autoPlaceTower = function autoPlaceTower() {
	// Use the first placement position which corresponds to nokta1 (enemy spawn area)
	var nokta1GridX = 11; // First placement square x coordinate
	var nokta1GridY = 6; // First placement square y coordinate
	// Check if we can place a default tower here
	if (canPlaceTowerType('default') && gold >= getTowerCost('default')) {
		// Place the default tower automatically
		if (placeTower(nokta1GridX, nokta1GridY, 'default')) {
			console.log("Default tower automatically placed at nokta1 spawn point");
			// Show placement notification after first tower is placed
			showPlacementNotification();
		}
	}
};
// Place tower immediately when game initializes
autoPlaceTower();
var nextWaveButton = new NextWaveButton();
nextWaveButton.x = 2048 / 2;
nextWaveButton.y = 2732 - 200;
game.addChild(nextWaveButton);
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 - 120; // Moved up by 30 pixels (was -90, now -120)
for (var i = 0; i < towerTypes.length; i++) {
	var tower = new SourceTower(towerTypes[i]);
	tower.x = startX + i * towerSpacing;
	// Apply smaller scale to all tower icons
	tower.scaleX = 0.7;
	tower.scaleY = 0.7;
	// Shift default tower icon slightly more to the left
	if (towerTypes[i] === 'default') {
		tower.x -= 150; // was 120, now more left
	}
	// Shift rapid tower icon further to the left
	if (towerTypes[i] === 'rapid') {
		tower.x -= 210; // was 180, now more left
		tower.scaleX = 0.6;
		tower.scaleY = 0.6;
	}
	// Shift sniper tower icon further to the left
	if (towerTypes[i] === 'sniper') {
		tower.x -= 290; // was 260, now more left
	}
	// Shift slow tower icon to the right
	if (towerTypes[i] === 'slow') {
		tower.x += 180;
	}
	// Shift splash tower icon to the right - move closer to slow tower
	if (towerTypes[i] === 'splash') {
		tower.x += 260;
	}
	// Shift poison tower icon to the right
	if (towerTypes[i] === 'poison') {
		tower.x += 120;
	}
	tower.y = towerY + 50; // Moved up by 20 pixels (was +70, now +50)
	towerLayer.addChild(tower);
	sourceTowers.push(tower);
}
sourceTower = null;
enemiesToSpawn = 10;
// Start playing background music
LK.playMusic('game_music');
game.update = function () {
	// Particle lifetime management - check and cleanup expired particles every 3 frames
	if (LK.ticks % 45 === 0) {
		// Check all active particles for lifetime expiration every 3 frames for aggressive cleanup
	}
	// Tween cleanup - clean up inactive tweens every 5 seconds
	if (LK.ticks % 1020 === 0) {
		// Removed call to cleanupInactiveTweens as it is undefined and unnecessary
	}
	// Update spatial partitioning grid for enemy targeting optimization
	// Visibility culling - hide objects outside screen bounds
	var screenMargin = 200; // Extra margin for smooth transitions
	for (var i = 0; i < enemies.length; i++) {
		var enemy = enemies[i];
		var isVisible = enemy.x > -screenMargin && enemy.x < 2048 + screenMargin && enemy.y > -screenMargin && enemy.y < 2732 + screenMargin;
		enemy.visible = isVisible;
	}
	// Prevent wave progression during black screen - only for wave 7
	var isBlackScreenActive = fadeToBlackStarted && bossWaveCompleted && currentWave === 7;
	// Also prevent wave 8 from starting automatically during black screen
	var preventWave8AutoStart = isBlackScreenActive && currentWave === 7;
	// Check if any vex enemies are still alive to block wave progression
	var vexEnemiesAlive = false;
	for (var i = 0; i < enemies.length; i++) {
		if (enemies[i].type === 'vex') {
			vexEnemiesAlive = true;
			break;
		}
	}
	// Block wave progression if vex enemies are still alive and trying to start wave 2
	var blockWaveForVex = vexEnemiesAlive && currentWave === 1 && waveTimer >= nextWaveTime;
	// Block all wave progression during black screen, including automatic wave 8 start, and when vex enemies are alive
	if (waveInProgress && !isBlackScreenActive && !preventWave8AutoStart && !(fadeToBlackStarted && currentWave >= 7) && !blockWaveForVex) {
		if (currentWave >= 2 && LK.ticks % 200 === 0) {
			// Every 3.33 seconds at 60 FPS (increased frequency from 5 seconds)
			var bird = new Bird();
			game.addChild(bird);
		}
		if (!waveSpawned && !spawnInProgress) {
			spawnInProgress = true; // Set spawn in progress flag
			enemiesSpawnedThisWave = 0; // Reset spawn counter for new wave
			// Clear any remaining enemies from previous waves to prevent confusion
			for (var oldEnemyIndex = enemies.length - 1; oldEnemyIndex >= 0; oldEnemyIndex--) {
				var oldEnemy = enemies[oldEnemyIndex];
				if (oldEnemy.waveNumber < currentWave) {
					// Remove old enemy that shouldn't still be spawning
					if (oldEnemy.parent) {
						if (oldEnemy.isFlying) {
							enemyLayerTop.removeChild(oldEnemy);
						} else {
							enemyLayerBottom.removeChild(oldEnemy);
						}
					}
					enemies.splice(oldEnemyIndex, 1);
				}
			}
			waveSpawned = true;
			// Play war sound only once when Wave 1 starts spawning (after button_start)
			if (currentWave === 1 && !warSoundPlayed) {
				warSoundPlayed = true;
				// Delay war sound to play after button_start sound finishes
				tween({}, {}, {
					duration: 1500,
					// Wait for button_start to finish
					onFinish: function onFinish() {
						console.log("Playing war sound for Wave 1");
						try {
							LK.getSound('war').play();
							console.log("War sound played successfully");
							// Play place sound 5 seconds after war sound
							tween({}, {}, {
								duration: 5000,
								onFinish: function onFinish() {
									LK.getSound('place').play();
									// Play sevda sound 5 seconds after place sound
									tween({}, {}, {
										duration: 5000,
										onFinish: function onFinish() {
											LK.getSound('sevda').play();
											// Play mov sound 5 seconds after sevda sound
											tween({}, {}, {
												duration: 5000,
												onFinish: function onFinish() {
													LK.getSound('mov').play();
													// Play og sound 5 seconds after mov sound
													tween({}, {}, {
														duration: 5000,
														onFinish: function onFinish() {
															LK.getSound('og').play();
															// Play miss sound 5 seconds after og sound
															tween({}, {}, {
																duration: 5000,
																onFinish: function onFinish() {
																	LK.getSound('miss').play();
																	missSoundStarted = true; // Set flag when miss sound starts
																	// guys sound is now played when vex enemy appears on screen
																}
															});
														}
													});
												}
											});
										}
									});
								}
							});
						} catch (e) {
							console.log("Error playing war sound:", e);
						}
					}
				});
			}
			// Play mezar sound only once when Wave 2 starts spawning
			if (currentWave === 2 && !mezarSoundPlayed) {
				mezarSoundPlayed = true;
				LK.getSound('mezar').play();
				showWaveNotification("Drones incoming!! Tap and send them to the scrapyard!!!", 5000); // Show notification for 5 seconds
			}
			// Play df sound only once when Wave 8 starts spawning
			if (currentWave === 8 && !window.dfSoundPlayed) {
				window.dfSoundPlayed = true;
				LK.getSound('df').play();
			}
			// We sound will be played when boss enemy appears on screen (moved to enemy entry logic)
			// 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 === 7;
			if (isBossWave && (waveType !== 'swarm' || waveType === 'big')) {
				// Boss waves and big enemies have just 1 enemy regardless of what the wave indicator says
				enemyCount = 1;
			}
			// Ensure wave 8+ enemy count is strictly limited to 3 (or 1 for boss waves)
			if (currentWave >= 8) {
				if (waveType === 'big' || currentWave % 10 === 0) {
					enemyCount = 1; // Boss waves always have 1 enemy
				} else {
					enemyCount = Math.min(3, enemyCount); // All other waves limited to 3 enemies
				}
			}
			// goddayfordie sound is now played when normal enemies enter screen
			// Reset sound flags for all enemies when new waves start (excluding the global first-time sounds)
			// Reset normal enemy specific sound flags to allow them to play again in new waves
			window.youAreKillingMeSoundPlayed = false;
			itDidntHurtSoundPlayed = false;
			youCantStopUsSoundPlayed = false;
			weAreComingForYouSoundPlayed = false;
			youwillnevergiveupSoundPlayed = false;
			gidiklaniyorumSoundPlayed = false;
			beCarefulSoundPlayed = false;
			sniperrSoundPlayed = false;
			keepMovingSoundPlayed = false;
			gogogoSniperSoundPlayed = false;
			// Reset goddayfordie sound flag to allow it to play again for normal enemies
			godDayForDieSoundPlayed = false;
			// Reset goddamit sound flag to allow it to play once per wave for splash bullets hitting normal enemies
			window.splashBulletSoundPlayed = false;
			window.splashBulletHitCount = 0;
			// Reset fast enemy sound flag for new wave
			fastEnemySoundPlayed = false;
			fastEnemySoundTimer = 0;
			// Reset xr sound flag for new wave
			window.xrSoundPlayed = false;
			// Reset yarış sound flag for new wave
			window.yarışSoundPlayed = false;
			// Reset guys sound flag for new wave
			window.guysSoundPlayed = false;
			// Reset slow tower area sound flags to allow them to repeat each wave
			welcomeToHellSoundPlayed = false;
			bronzSoundPlayed = false;
			sunSoundPlayed = false;
			slowAreaEnemyCount = 0; // Reset counter for bronz sound timing
			// Reset wifi sound flag for new wave
			wifiSoundPlayedThisWave = false;
			// Reset taksi sound flag for new wave
			taksiSoundPlayedThisWave = false;
			// Reset vasiyet sound flag for new wave
			vasiyetSoundPlayedThisWave = false;
			rapidBulletImmuneHitCount = 0;
			// Reset gözlük sound flag for new wave
			gözlükSoundPlayedThisWave = false;
			sniperBulletImmuneHitCount = 0;
			// Reset shy sound flag for new wave
			shySoundPlayedThisWave = false;
			slowBulletImmuneHitCount = 0;
			// Reset krk sound flag for new wave
			window.krkSoundPlayedThisWave = false;
			// Reset mask sound flag for new wave
			window.maskSoundPlayedThisWave = false;
			// Reset shoes sound flag for new wave
			window.shoesSoundPlayed = false;
			// Reset browser sound flag for new wave
			window.browserSoundPlayed = false;
			// Reset browser sound wave flag for new wave
			browserSoundPlayedThisWave = false;
			// Reset sniper immune hit counter for new wave
			if (typeof window.sniperImmuneHitCounter !== 'undefined') {
				window.sniperImmuneHitCounter = 0;
			}
			// Reset splash immune hit counter for new wave
			window.splashImmuneHitCounter = 0;
			// Spawn the appropriate number of enemies with stricter counter protection
			// Double-check that we don't exceed the enemy count for this wave
			var actualEnemyCount = Math.min(enemyCount, currentWave >= 8 ? 3 : enemyCount);
			var _spawnEnemy = function spawnEnemy(index) {
				if (index >= actualEnemyCount || enemiesSpawnedThisWave >= actualEnemyCount) return;
				var enemyType = waveType;
				var enemy;
				// Special handling for Wave 1: spawn only blue enemies initially
				if (currentWave === 1) {
					// All enemies in Wave 1 are blue - vex will spawn later
					enemyType = 'blue';
					enemy = new Enemy(enemyType);
				} else if (enemyType === 'blue') {
					// Blue enemies can only be used in wave 1, replace with normal for other waves
					enemyType = 'normal';
					enemy = new Enemy(enemyType);
				} else if (currentWave === 4 && waveType === 'flying') {
					// Wave 4 special: spawn only flying enemies during normal spawning
					// Fex enemy will be spawned separately after sm sound
					enemy = new Enemy('flying');
				} else {
					enemy = new Enemy(enemyType);
				}
				// Add enemy to the appropriate layer based on type
				if (enemy.isFlying) {
					// Add flying enemy to the top layer
					enemyLayerTop.addChild(enemy);
				} else {
					// Add normal/ground enemies to the bottom layer
					enemyLayerBottom.addChild(enemy);
				}
				// Fixed health values for each wave based on requirements
				var fixedHealth;
				switch (currentWave) {
					case 1:
						fixedHealth = 275; // 1100 total health for 4 blue enemies (275 x 4 = 1100)
						break;
					case 2:
						fixedHealth = 367; // 1100 total health for 3 immune enemies (367 x 3 = 1101, close to 1100)
						break;
					case 3:
						fixedHealth = 367; // 1100 total health for 3 normal enemies (367 x 3 = 1101, close to 1100)
						break;
					case 4:
						fixedHealth = 550; // 1100 total health for 2 flying enemies (550 x 2 = 1100)
						break;
					case 5:
						fixedHealth = 233; // 233 x 3 = 699, close to 700 total for fast enemies
						break;
					case 6:
						fixedHealth = 367; // 1100 total health for 3 swarm enemies (367 x 3 = 1101, close to 1100)
						break;
					case 7:
						fixedHealth = 900;
						break;
					default:
						// For waves 8+, start at 600 health and increase by 20 each wave
						if (currentWave >= 8) {
							if (currentWave === 8) {
								fixedHealth = 317; // 317 x 3 = 951, close to 950 total
							} else if (currentWave === 9) {
								fixedHealth = 317; // 317 x 3 = 951, close to 950 total
							} else if (currentWave === 10) {
								fixedHealth = 317; // 317 x 3 = 951, close to 950 total
							} else if (currentWave === 11) {
								fixedHealth = 317; // 317 x 3 = 951, close to 950 total for wave 11
							} else if (currentWave === 12) {
								fixedHealth = 317; // 317 x 3 = 951, close to 950 total for wave 12
							} else if (currentWave === 13) {
								fixedHealth = 317; // 317 x 3 = 951, close to 950 total for wave 13
							} else if (currentWave === 14) {
								fixedHealth = 317; // 317 x 3 = 951, close to 950 total for wave 14
							} else if (currentWave === 15) {
								fixedHealth = 317; // 317 x 3 = 951, close to 950 total for wave 15
							} else if (currentWave >= 16 && currentWave <= 25) {
								fixedHealth = 317; // 317 x 3 = 951, close to 950 total for waves 16-25
							} else {
								fixedHealth = 600 + (currentWave - 8) * 20; // 600 for wave 26+, +20 each wave
							}
						} else {
							// Fallback for any unexpected cases
							fixedHealth = 600;
						}
						// Boss waves get extra health
						if (currentWave % 10 === 0) {
							fixedHealth = Math.floor(fixedHealth * 2.5); // Boss waves have 2.5x health
						}
						break;
				}
				// Boss wave special handling - use direct health values for boss enemies
				if (isBossWave) {
					if (waveType === 'big') {
						// Big boss keeps the 2000 health set above
					} else {
						// Other bosses keep the 2000 health set above
					}
				}
				enemy.maxHealth = fixedHealth;
				enemy.health = enemy.maxHealth;
				// Increment speed slightly with wave number
				//enemy.speed = enemy.speed + currentWave * 0.002;
				// Handle vex enemy spawn location specially
				var spawnX;
				if (enemyType === 'vex') {
					// Vex enemy always spawns from column 14
					spawnX = 14;
				} else if (enemyType === 'fex' || enemyType === 'findik') {
					// Fex and Fındık always spawn at gridX 13
					spawnX = 13;
				} else {
					// All other enemy types 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
					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);
				enemiesSpawnedThisWave++; // Increment spawn counter
				// Schedule next enemy spawn with 1ms delay
				LK.setTimeout(function () {
					_spawnEnemy(index + 1);
				}, 1);
			};
			_spawnEnemy(0);
			// Complete spawn process - only set waveSpawned to true after ALL enemies are spawned
			spawnInProgress = false; // Clear spawn in progress flag
			// Final validation: ensure we haven't exceeded the enemy limit for wave 8+
			if (currentWave >= 8) {
				var currentWaveEnemyCount = 0;
				for (var checkIndex = 0; checkIndex < enemies.length; checkIndex++) {
					if (enemies[checkIndex].waveNumber === currentWave) {
						currentWaveEnemyCount++;
					}
				}
				// If we somehow spawned too many enemies, remove the excess
				if (currentWaveEnemyCount > 3) {
					for (var excessIndex = enemies.length - 1; excessIndex >= 0 && currentWaveEnemyCount > 3; excessIndex--) {
						var excessEnemy = enemies[excessIndex];
						if (excessEnemy.waveNumber === currentWave) {
							if (excessEnemy.parent) {
								if (excessEnemy.isFlying) {
									enemyLayerTop.removeChild(excessEnemy);
								} else {
									enemyLayerBottom.removeChild(excessEnemy);
								}
							}
							enemies.splice(excessIndex, 1);
							currentWaveEnemyCount--;
						}
					}
				}
			}
		}
		var currentWaveEnemiesRemaining = false;
		for (var i = 0; i < enemies.length; i++) {
			if (enemies[i].waveNumber === currentWave) {
				currentWaveEnemiesRemaining = true;
				break;
			}
		}
		// Continue spawning crows until the screen fades to black
		if (!fadeToBlackStarted || currentWave < 8) {
			if (currentWave >= 2 && LK.ticks % 200 === 0) {
				// Every 3.33 seconds at 60 FPS
				var bird = new Bird();
				game.addChild(bird);
			}
		}
		// Special handling for Wave 1: spawn vex enemy 3 seconds after miss sound starts playing
		// The miss sound is triggered after og sound, so we need to detect when it starts + 3 seconds
		if (currentWave === 1 && waveSpawned && !wave1VexSpawned && !spawnInProgress) {
			// Check if miss sound has started and spawn vex enemy 3 seconds after
			if (missSoundStarted && !vexSpawnTimerStarted) {
				vexSpawnTimerStarted = true;
				vexSpawnTimer = LK.ticks;
			}
			if (vexSpawnTimerStarted && LK.ticks - vexSpawnTimer >= 660) {
				// 660 frames = 11 seconds at 60 FPS
				wave1VexSpawned = true;
				var vexEnemy = new Enemy('vex');
				// Add vex enemy to the appropriate layer
				if (vexEnemy.isFlying) {
					enemyLayerTop.addChild(vexEnemy);
				} else {
					enemyLayerBottom.addChild(vexEnemy);
				}
				// Set vex enemy health for wave 1
				vexEnemy.maxHealth = 195; // Same as other wave 1 enemies
				vexEnemy.health = vexEnemy.maxHealth;
				// Vex enemy spawns from column 14
				var spawnX = 14;
				var spawnY = -1 - Math.random() * 5; // Random distance above the grid for spreading
				vexEnemy.cellX = spawnX;
				vexEnemy.cellY = 5; // Position after entry
				vexEnemy.currentCellX = spawnX;
				vexEnemy.currentCellY = spawnY;
				vexEnemy.waveNumber = currentWave;
				enemies.push(vexEnemy);
				enemiesSpawnedThisWave++; // Count vex enemy in spawn total
			}
		}
		if (waveSpawned && !currentWaveEnemiesRemaining) {
			// Add +150 gold reward when Wave 5 is completed
			if (currentWave === 5) {
				var goldEarned = 150;
				var goldIndicator = new GoldIndicator(goldEarned, 2048 / 2, 2732 / 2);
				game.addChild(goldIndicator);
				setGold(gold + goldEarned);
			}
			// Add +10 gold reward when Wave 1 is completed
			if (currentWave === 1) {
				var goldEarned = 10;
				var goldIndicator = new GoldIndicator(goldEarned, 2048 / 2, 2732 / 2);
				game.addChild(goldIndicator);
				setGold(gold + goldEarned);
			}
			// Add +20 gold reward when Wave 2 is completed
			if (currentWave === 2) {
				var goldEarned = 20;
				var goldIndicator = new GoldIndicator(goldEarned, 2048 / 2, 2732 / 2);
				game.addChild(goldIndicator);
				setGold(gold + goldEarned);
			}
			// Add +30 gold reward when Wave 3 is completed
			if (currentWave === 3) {
				var goldEarned = 30;
				var goldIndicator = new GoldIndicator(goldEarned, 2048 / 2, 2732 / 2);
				game.addChild(goldIndicator);
				setGold(gold + goldEarned);
			}
			waveInProgress = false;
			waveSpawned = false;
			spawnInProgress = false; // Reset spawn protection flag
			enemiesSpawnedThisWave = 0; // Reset spawn counter
			// CRITICAL: Clean up after each completed wave to prevent memory leaks
			// Reset vex spawn flag for next game
			if (currentWave === 1) {
				wave1VexSpawned = false;
			}
			// Set timer to automatically start next wave after 7 seconds if not at final wave
			// But only if we're not in black screen state
			if (currentWave < totalWaves && !isBlackScreenActive) {
				waveTimer = nextWaveTime - 420; // 7 seconds = 420 frames at 60fps, so next wave starts in 7 seconds
			}
		}
	}
	// Check for enemies exiting slow tower area
	for (var i = enemiesInSlowArea.length - 1; i >= 0; i--) {
		var enemy = enemiesInSlowArea[i];
		var stillInSlowArea = false;
		// Check if enemy is still in range of any slow tower
		for (var t = 0; t < towers.length; t++) {
			var tower = towers[t];
			if (tower.id === 'slow') {
				var dx = enemy.x - tower.x;
				var dy = enemy.y - tower.y;
				var distance = Math.sqrt(dx * dx + dy * dy);
				if (distance <= tower.getRange()) {
					stillInSlowArea = true;
					break;
				}
			}
		}
		// If enemy is no longer in slow area or has been destroyed, remove from tracking
		if (!stillInSlowArea || !enemy.parent || enemy.health <= 0) {
			enemiesInSlowArea.splice(i, 1);
			// Play sun sound if this was the last enemy and sound hasn't been played yet (excluding blue enemies, Wave 7 big enemy, fex, and fındık enemies)
			if (enemiesInSlowArea.length === 0 && !sunSoundPlayed && currentWave !== 5) {
				// Exclude sun sound for big enemy in wave 7, fex, and fındık enemies
				if (!(currentWave === 7 && enemy.type === 'big') && enemy.type !== 'blue' && enemy.type !== 'fex' && enemy.type !== 'findik') {
					sunSoundPlayed = true;
					LK.getSound('sun').play();
				}
			}
		}
	}
	// Aggressive enemies array cleanup - enforce maximum size limit
	var maxEnemiesLimit = 45; // Change maximum active enemies to 45 for better mobile performance
	if (enemies.length > maxEnemiesLimit) {
		// Force cleanup of oldest enemies that are off-screen or invalid
		for (var cleanupIndex = enemies.length - 1; cleanupIndex >= 0 && enemies.length > maxEnemiesLimit; cleanupIndex--) {
			var enemyToCleanup = enemies[cleanupIndex];
			// CRITICAL: Never remove Fındık enemies - they are special immortal enemies
			if (enemyToCleanup && enemyToCleanup.type === 'findik') {
				continue; // Skip removal of Fındık enemies
			}
			if (!enemyToCleanup || !enemyToCleanup.parent || enemyToCleanup.y < -200 || enemyToCleanup.y > 3000) {
				// Force cleanup enemy that's invalid or far off-screen
				if (enemyToCleanup && enemyToCleanup.parent) {
					if (enemyToCleanup.isFlying) {
						enemyLayerTop.removeChild(enemyToCleanup);
					} else {
						enemyLayerBottom.removeChild(enemyToCleanup);
					}
				}
				enemies.splice(cleanupIndex, 1);
			}
		}
	}
	for (var a = enemies.length - 1; a >= 0; a--) {
		var enemy = enemies[a];
		// Additional safety check for invalid enemies
		if (!enemy || !enemy.parent) {
			enemies.splice(a, 1);
			continue;
		}
		if (enemy.health <= 0) {
			spatialGrid.clear(); // Clear the spatial grid
			for (var i = 0; i < enemies.length; i++) {
				spatialGrid.addEnemy(enemies[i]); // Re-add remaining enemies to the grid
			}
			// Update spatial grid when an enemy is removed
			spatialGrid.clear();
			for (var i = 0; i < enemies.length; i++) {
				spatialGrid.addEnemy(enemies[i]);
			}
			// Critical fix: Never remove Fındık enemies - they are immortal
			if (enemy.type === 'findik') {
				// Force health back to full for immortal enemies
				enemy.health = enemy.maxHealth;
				// Also ensure health bar is full
				if (enemy.healthBar) enemy.healthBar.width = 70;
				continue;
			}
			// Fex enemies can die normally when health reaches 0
			// Simple validation - only remove enemies that are actually dead
			if (enemy.health > 0) {
				// Enemy still has health, don't remove
				continue;
			}
			// Aggressive cleanup of bullet references
			if (enemy.bulletsTargetingThis) {
				for (var i = 0; i < enemy.bulletsTargetingThis.length; i++) {
					var bullet = enemy.bulletsTargetingThis[i];
					if (bullet) {
						bullet.targetEnemy = null;
					}
				}
				// Clear the array completely to prevent memory leaks
				enemy.bulletsTargetingThis.length = 0;
				enemy.bulletsTargetingThis = null;
			}
			// Clean up walking feet for normal, swarm, blue, and fex enemies only (no longer need to return to pool)
			if ((enemy.type === 'normal' || enemy.type === 'swarm' || enemy.type === 'blue' || enemy.type === 'vex' || enemy.type === 'fex') && !enemy.isBoss && enemy.leftFoot && enemy.rightFoot) {
				// Feet are now regular child objects, they'll be destroyed automatically with the enemy
				enemy.leftFoot = null;
				enemy.rightFoot = null;
			}
			// Enemy death animation removed
			// Calculate gold and score rewards with improved scaling - include fex enemies
			var isEliteWave = enemy.waveNumber === 7;
			var goldEarned = isEliteWave ? Math.floor(18 + (enemy.waveNumber - 1) * 2.5) : Math.floor(1.5 + (enemy.waveNumber - 1) * 0.7);
			var goldIndicator = new GoldIndicator(goldEarned, enemy.x, enemy.y);
			game.addChild(goldIndicator);
			setGold(gold + goldEarned);
			// Give more score for elite enemies
			var scoreValue = isEliteWave ? 25 : 5;
			score += 1; // Award 1 point for each enemy killed
			updateUI();
			// Remove enemy from the appropriate layer
			if (enemy.isFlying) {
				enemyLayerTop.removeChild(enemy);
			} else {
				enemyLayerBottom.removeChild(enemy);
			}
			// Force cleanup of enemy references before removal
			enemy.targetEnemy = null;
			enemy.currentTarget = null;
			if (enemy.bulletsTargetingThis) {
				enemy.bulletsTargetingThis = null;
			}
			enemies.splice(a, 1);
			continue;
		}
		if (grid.updateEnemy(enemy)) {
			spatialGrid.clear(); // Clear the spatial grid
			for (var i = 0; i < enemies.length; i++) {
				spatialGrid.addEnemy(enemies[i]); // Re-add remaining enemies to the grid
			}
			// Never remove Fındık enemies even if updateEnemy returns true
			if (enemy.type === 'findik') {
				// These enemies should never be removed - they stay in the game forever
				continue;
			}
			// Allow fex enemies to be removed normally when they reach the goal
			// Clean up walking feet for normal, swarm, and blue enemies only (no longer need to return to pool)
			if ((enemy.type === 'normal' || enemy.type === 'swarm' || enemy.type === 'blue' || enemy.type === 'vex') && !enemy.isBoss && enemy.leftFoot && enemy.rightFoot) {
				// Feet are now regular child objects, they'll be destroyed automatically with the enemy
				enemy.leftFoot = null;
				enemy.rightFoot = null;
			}
			// Increment counter for enemies reaching goal
			enemiesReachedGoalCount++;
			// Play "wewin" sound on 5th enemy reaching goal with delay
			if (enemiesReachedGoalCount === 5 && canPlaySound('wewin', weWinSoundCooldown)) {
				// Delay the sound by 1200ms for clear speech
				tween({}, {}, {
					duration: 1200,
					onFinish: function onFinish() {
						LK.getSound('wewin').play();
					}
				});
			}
			// Remove enemy from the appropriate layer
			if (enemy.isFlying) {
				enemyLayerTop.removeChild(enemy);
			} else {
				enemyLayerBottom.removeChild(enemy);
			}
			enemies.splice(a, 1);
			lives = Math.max(0, lives - 1);
			updateUI();
			if (lives <= 0) {
				LK.showGameOver();
			}
		}
	}
	if (towerPreview.visible) {
		towerPreview.checkPlacement();
	}
	// Smart pathfinding optimization: only trigger when enemies need updated paths
	var needsPathfindingUpdate = false;
	for (var i = 0; i < enemies.length; i++) {
		var enemy = enemies[i];
		// Only trigger pathfinding for enemies that have entered the gameplay area
		if (enemy.currentCellY >= 4 && !enemy.isFlying && enemy.type !== 'vex') {
			// Check if enemy has a valid current target with correct pathId
			if (!enemy.currentTarget || enemy.currentTarget.pathId !== pathId) {
				needsPathfindingUpdate = true;
				break;
			}
		}
	}
	// Trigger pathfinding update only when needed and not too frequently
	if (needsPathfindingUpdate && (!pathfindingCache || LK.ticks - lastPathfindTime > 720)) {
		if (!pathfindingCache || LK.ticks - lastPathfindTime > pathfindCacheTimeout) {
			grid.pathFind();
			pathfindingCache = {
				maxScore: maxScore,
				pathId: pathId,
				type: requestType
			};
			for (var i = 0; i < grid.cells.length; i++) {
				pathfindingCache[i] = [];
				for (var j = 0; j < grid.cells[i].length; j++) {
					var cell = grid.cells[i][j];
					pathfindingCache[i][j] = {
						score: cell.score,
						pathId: cell.pathId,
						targets: cell.targets.slice() // Copy array
					};
				}
			}
			lastPathfindTime = LK.ticks;
		} else {
			// Reuse cached pathfinding results
			maxScore = pathfindingCache.maxScore;
			pathId = pathfindingCache.pathId;
			requestType = pathfindingCache.type;
			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];
					var cachedCell = pathfindingCache[i][j];
					cell.score = cachedCell.score;
					cell.pathId = cachedCell.pathId;
					cell.targets = cachedCell.targets.slice(); // Copy array
				}
			}
		}
	}
	// Fast enemy sounds are now handled in enemy update logic when they appear on screen
	// Check if wave 7 (boss wave) is completed
	if (currentWave === 7 && enemies.length === 0 && !waveInProgress && !bossWaveCompleted) {
		bossWaveCompleted = true;
		// Start fade to black effect after boss wave completion
		if (!fadeToBlackStarted) {
			fadeToBlackStarted = true;
			// Create black overlay
			var blackOverlay = game.attachAsset('notification', {
				anchorX: 0,
				anchorY: 0,
				width: 2048,
				height: 2732,
				x: 0,
				y: 0
			});
			blackOverlay.tint = 0x000000;
			blackOverlay.alpha = 0;
			// Slowly fade everything to black
			tween(blackOverlay, {
				alpha: 1
			}, {
				duration: 3000,
				// 3 seconds fade
				easing: tween.easeInOut,
				onFinish: function onFinish() {
					// Everything is now black - add center text
					console.log("Fade to black complete");
					// Play 'son' sound when screen goes black
					LK.getSound('son').play();
					// Music continues playing during black screen
					// No music fade out or restrictions
					// Create center text that appears after fade
					var centerText = new Text2("And the war is over", {
						size: 150,
						fill: 0xFFFFFF,
						weight: 800
					});
					centerText.anchor.set(0.5, 0.5);
					centerText.x = 2048 / 2;
					centerText.y = 2732 / 2 - 200; // Move text up to make room for buttons
					centerText.alpha = 0;
					game.addChild(centerText);
					// Create home button
					var homeButton = new Container();
					var homeButtonBg = homeButton.attachAsset('notification', {
						anchorX: 0.5,
						anchorY: 0.5
					});
					homeButtonBg.width = 600;
					homeButtonBg.height = 180;
					homeButtonBg.tint = 0xFF0000;
					var homeButtonText = new Text2("home", {
						size: 80,
						fill: 0xFFFFFF,
						weight: 800
					});
					homeButtonText.anchor.set(0.5, 0.5);
					homeButton.addChild(homeButtonText);
					homeButton.x = 2048 / 2 - 350;
					homeButton.y = 2732 / 2 + 250;
					homeButton.alpha = 0;
					game.addChild(homeButton);
					// Create continue button
					var continueButton = new Container();
					var continueButtonBg = continueButton.attachAsset('notification', {
						anchorX: 0.5,
						anchorY: 0.5
					});
					continueButtonBg.width = 600;
					continueButtonBg.height = 180;
					continueButtonBg.tint = 0x00FF00;
					var continueButtonText = new Text2("continue", {
						size: 80,
						fill: 0xFFFFFF,
						weight: 800
					});
					continueButtonText.anchor.set(0.5, 0.5);
					continueButton.addChild(continueButtonText);
					continueButton.x = 2048 / 2 + 350;
					continueButton.y = 2732 / 2 + 250;
					continueButton.alpha = 0;
					game.addChild(continueButton);
					// Add button click handlers
					homeButton.down = function () {
						// Show you win screen instead of reloading
						LK.showYouWin();
					};
					continueButton.down = function () {
						// Stop son sound if it's currently playing
						try {
							LK.getSound('son').stop();
						} catch (e) {
							// Sound might not support stop method, ignore error
						}
						// Continue to next wave (Wave 8)
						// Hide the overlay and buttons
						blackOverlay.alpha = 0;
						centerText.alpha = 0;
						homeButton.alpha = 0;
						continueButton.alpha = 0;
						// IMPORTANT: Reset black screen state FIRST to disable it for waves 8+
						bossWaveCompleted = false;
						fadeToBlackStarted = false;
						// Reset game state for next wave (only set to 8 if we're actually at wave 7)
						if (currentWave === 7) {
							currentWave = 8; // Only advance to wave 8 if we're coming from wave 7
						}
						waveTimer = 0; // Reset timer to start next wave immediately
						waveInProgress = true;
						waveSpawned = false;
						// Music already playing, no need to restore
						// Re-enable bird sounds
						if (birdDisplay) {
							birdDisplay.update = function () {
								birdSoundTimer++;
								if (birdSoundTimer >= nextBirdSoundTime) {
									LK.getSound('bird_chirp').play();
									birdSoundTimer = 0;
									nextBirdSoundTime = 480 + Math.random() * 240; // Reset timer for next chirp
								}
							};
						}
					};
					// Fade in the center text and buttons
					tween(centerText, {
						alpha: 1
					}, {
						duration: 2000,
						easing: tween.easeInOut,
						onFinish: function onFinish() {
							// After text fades in, fade in buttons
							tween(homeButton, {
								alpha: 1
							}, {
								duration: 1000,
								easing: tween.easeInOut
							});
							tween(continueButton, {
								alpha: 1
							}, {
								duration: 1000,
								easing: tween.easeInOut
							});
						}
					});
				}
			});
		}
	}
	// Helper function to check if sounds should be muted during black screen
	function shouldMuteSound(soundId) {
		var isBlackScreenActive = fadeToBlackStarted && bossWaveCompleted && currentWave === 7;
		if (!isBlackScreenActive) {
			return false; // No black screen, don't mute
		}
		// During black screen, only allow 'son' sound to play
		return soundId !== 'son';
	}
	// Override LK.getSound to apply muting during black screen
	var originalGetSound = LK.getSound;
	LK.getSound = function (soundId) {
		var sound = originalGetSound.call(this, soundId);
		var originalPlay = sound.play;
		sound.play = function () {
			if (shouldMuteSound(soundId)) {
				return; // Mute this sound during black screen
			}
			return originalPlay.call(this);
		};
		return sound;
	};
	// Periodic array cleanup and maintenance to prevent memory leaks
	if (LK.ticks - lastArrayCleanupTime >= arrayCleanupInterval * 2) {
		lastArrayCleanupTime = LK.ticks;
		// Clean up invalid tower references
		for (var t = towers.length - 1; t >= 0; t--) {
			var tower = towers[t];
			if (!tower || !tower.parent) {
				// Force cleanup tower references
				if (tower) {
					tower.targetEnemy = null;
					if (tower.cellsInRange) {
						// Clean up cell references to this tower
						for (var c = 0; c < tower.cellsInRange.length; c++) {
							var cell = tower.cellsInRange[c];
							if (cell && cell.towersInRange) {
								var towerIndex = cell.towersInRange.indexOf(tower);
								if (towerIndex !== -1) {
									cell.towersInRange.splice(towerIndex, 1);
								}
							}
						}
						tower.cellsInRange.length = 0;
						tower.cellsInRange = null;
					}
				}
				towers.splice(t, 1);
			}
		}
		// Force garbage collection hints by nullifying unused references
		if (enemies.length === 0 && !waveInProgress) {
			// Clean up any residual enemy references when no enemies present
			for (var b = bullets.length - 1; b >= 0; b--) {
				var bulletForCleanup = bullets[b];
				if (bulletForCleanup && (!bulletForCleanup.targetEnemy || bulletForCleanup.targetEnemy.health <= 0)) {
					if (bulletForCleanup.parent) {
						bulletForCleanup.parent.removeChild(bulletForCleanup);
					}
					bulletForCleanup.targetEnemy = null;
					bulletForCleanup.sourceTower = null;
					bullets.splice(b, 1);
				}
			}
		}
		// Enforce strict limits on all arrays
		var maxEnemies = Math.min(30, currentWave * 5); // Scale with wave but cap at 30
		var maxBullets = 35; // Change maximum active bullets to 35 for better mobile performance
		var maxTowers = 6; // Set the maximum number of towers that can be placed to 6
		// Trim arrays if they exceed limits
		if (enemies.length > maxEnemies) {
			enemies.length = maxEnemies;
		}
		if (towers.length > maxTowers) {
			towers.length = maxTowers;
		}
	}
	// Win condition: Only show you win when all 50 waves are completed
	if (currentWave >= totalWaves && enemies.length === 0 && !waveInProgress) {
		LK.showYouWin();
	}
};
// Create a play button and add it to the center of the game screen
var playButton = game.attachAsset('play_button', {
	anchorX: 0.5,
	anchorY: 0.5,
	x: 2048 / 2,
	y: 2732 / 2
});
// Add an event listener to hide the play button when it is touched
playButton.down = function () {
	LK.getSound('plays').play();
	// Play 'stry' sound after 'plays' sound finishes (assume 500ms is enough for button sound)
	tween({}, {}, {
		duration: 500,
		onFinish: function onFinish() {
			LK.getSound('stry').play();
		}
	});
	playButton.visible = false;
	var saykoVisual = new SaykoVisual();
	game.addChild(saykoVisual);
};
// Function to display a notification text in the center of the screen
function showWaveNotification(message, duration) {
	// Bildirim mesajlarını Türkçeye çevir
	var trMap = {
		"Drones incoming!! Tap and send them to the scrapyard!!!": "Dronlar geliyor! Dokun ve hurdalığa gönder!"
	};
	var trMsg = trMap[message] || message;
	var notificationText = new Text2(trMsg, {
		size: 60,
		fill: 0xFFFFFF,
		weight: 800
	});
	notificationText.anchor.set(0.5, 0.5);
	notificationText.x = 2048 / 2;
	notificationText.y = 2732 / 2;
	game.addChild(notificationText);
	// Fade out the notification after the specified duration
	tween(notificationText, {
		alpha: 0
	}, {
		duration: duration,
		easing: tween.easeInOut,
		onFinish: function onFinish() {
			if (notificationText.parent) {
				notificationText.parent.removeChild(notificationText);
			}
		}
	});
}
var soundCooldowns = {};
function canPlaySound(soundId, cooldownMs) {
	var now = LK.ticks;
	var lastPlayed = soundCooldowns[soundId] || 0;
	if (now - lastPlayed > cooldownMs) {
		soundCooldowns[soundId] = now;
		return true;
	}
	return false;
}
var SoundChainManager = {
	soundChains: {
		wave1Start: [{
			sound: 'war',
			delay: 0
		}, {
			sound: 'place',
			delay: 5000
		}, {
			sound: 'sevda',
			delay: 5000
		}, {
			sound: 'mov',
			delay: 5000
		}, {
			sound: 'og',
			delay: 5000
		}, {
			sound: 'miss',
			delay: 5000
		}],
		swarmBulletChain: [{
			sound: 'youcantstopus',
			delay: 0
		}, {
			sound: 'browser',
			delay: 2000
		}, {
			sound: 'tnk',
			delay: 5000
		}, {
			sound: 'borc',
			delay: 4000
		}, {
			sound: 'db',
			delay: 4000
		}],
		ratEntryChain: [{
			sound: 'wu',
			delay: 0
		}, {
			sound: 'bolt',
			delay: 3000
		}, {
			sound: 'hamburger',
			delay: 10000
		}, {
			sound: 'kola',
			delay: 10000
		}, {
			sound: 'hungry',
			delay: 10000
		}],
		flyingWave4Chain: [{
			sound: 'xr',
			delay: 0
		}, {
			sound: 'yar',
			delay: 4000
		}, {
			sound: 'upit',
			delay: 5000
		}, {
			sound: 'water',
			delay: 4000
		}, {
			sound: 'funny',
			delay: 5000
		}, {
			sound: 'z',
			delay: 5000
		}, {
			sound: 'sm',
			delay: 3000
		}],
		fexEnemyChain: [{
			sound: 'dog',
			delay: 0
		}, {
			sound: 'hav',
			delay: 22000
		}, {
			sound: 'ner',
			delay: 5000
		}, {
			sound: 'hv2',
			delay: 1000
		}, {
			sound: 'hv3',
			delay: 3000
		}, {
			sound: 'hv3',
			delay: 2000
		}, {
			sound: 'hv4',
			delay: 3000
		}, {
			sound: 'hlp',
			delay: 3000
		}],
		wave7BossChain: [{
			sound: 'we',
			delay: 0
		}, {
			sound: 'ek',
			delay: 2000
		}, {
			sound: 'tw',
			delay: 2000
		}, {
			sound: 'sh',
			delay: 15000
		}],
		fastEnemyWave5Chain: [{
			sound: 'fast_enemy_sound',
			delay: 0
		}, {
			sound: 'for_the_fallen',
			delay: 5000
		}]
	},
	activeChains: [],
	chainCooldowns: {},
	startSoundChain: function startSoundChain(chainName) {
		if (this.chainCooldowns[chainName] && LK.ticks - this.chainCooldowns[chainName] < 30000) {
			return;
		}
		this.chainCooldowns[chainName] = LK.ticks;
		var chain = {
			name: chainName,
			sounds: this.soundChains[chainName].slice(),
			currentIndex: 0,
			nextPlayTime: LK.ticks
		};
		this.activeChains.push(chain);
	},
	updateSoundChains: function updateSoundChains() {
		for (var i = this.activeChains.length - 1; i >= 0; i--) {
			var chain = this.activeChains[i];
			if (LK.ticks >= chain.nextPlayTime) {
				var soundData = chain.sounds[chain.currentIndex];
				LK.getSound(soundData.sound).play();
				this.handleChainSpecialActions(chain.name, chain.currentIndex);
				chain.currentIndex++;
				if (chain.currentIndex >= chain.sounds.length) {
					this.activeChains.splice(i, 1);
				} else {
					chain.nextPlayTime = LK.ticks + chain.sounds[chain.currentIndex].delay;
				}
			}
		}
	},
	handleChainSpecialActions: function handleChainSpecialActions(chainName, soundIndex) {
		if (chainName === 'flyingWave4Chain' && soundIndex === 6) {
			spawnFexEnemy();
		}
	}
};
var SoundChainManager = {
	soundChains: {
		wave1Start: [{
			sound: 'war',
			delay: 0
		}, {
			sound: 'place',
			delay: 5000
		}, {
			sound: 'sevda',
			delay: 5000
		}, {
			sound: 'mov',
			delay: 5000
		}, {
			sound: 'og',
			delay: 5000
		}, {
			sound: 'miss',
			delay: 5000
		}],
		swarmBulletChain: [{
			sound: 'youcantstopus',
			delay: 0
		}, {
			sound: 'browser',
			delay: 2000
		}, {
			sound: 'tnk',
			delay: 5000
		}, {
			sound: 'borc',
			delay: 4000
		}, {
			sound: 'db',
			delay: 4000
		}],
		ratEntryChain: [{
			sound: 'wu',
			delay: 0
		}, {
			sound: 'bolt',
			delay: 3000
		}, {
			sound: 'hamburger',
			delay: 10000
		}, {
			sound: 'kola',
			delay: 10000
		}, {
			sound: 'hungry',
			delay: 10000
		}],
		flyingWave4Chain: [{
			sound: 'xr',
			delay: 0
		}, {
			sound: 'yar',
			delay: 4000
		}, {
			sound: 'upit',
			delay: 5000
		}, {
			sound: 'water',
			delay: 4000
		}, {
			sound: 'funny',
			delay: 5000
		}, {
			sound: 'z',
			delay: 5000
		}, {
			sound: 'sm',
			delay: 3000
		}],
		fexEnemyChain: [{
			sound: 'dog',
			delay: 0
		}, {
			sound: 'hav',
			delay: 22000
		}, {
			sound: 'ner',
			delay: 5000
		}, {
			sound: 'hv2',
			delay: 1000
		}, {
			sound: 'hv3',
			delay: 3000
		}, {
			sound: 'hv3',
			delay: 2000
		}, {
			sound: 'hv4',
			delay: 3000
		}, {
			sound: 'hlp',
			delay: 3000
		}],
		wave7BossChain: [{
			sound: 'we',
			delay: 0
		}, {
			sound: 'ek',
			delay: 2000
		}, {
			sound: 'tw',
			delay: 2000
		}, {
			sound: 'sh',
			delay: 15000
		}],
		fastEnemyWave5Chain: [{
			sound: 'fast_enemy_sound',
			delay: 0
		}, {
			sound: 'for_the_fallen',
			delay: 5000
		}]
	},
	activeChains: [],
	chainCooldowns: {},
	startSoundChain: function startSoundChain(chainName) {
		if (this.chainCooldowns[chainName] && LK.ticks - this.chainCooldowns[chainName] < 30000) {
			return;
		}
		this.chainCooldowns[chainName] = LK.ticks;
		var chain = {
			name: chainName,
			sounds: this.soundChains[chainName].slice(),
			currentIndex: 0,
			nextPlayTime: LK.ticks
		};
		this.activeChains.push(chain);
	},
	updateSoundChains: function updateSoundChains() {
		for (var i = this.activeChains.length - 1; i >= 0; i--) {
			var chain = this.activeChains[i];
			if (LK.ticks >= chain.nextPlayTime) {
				var soundData = chain.sounds[chain.currentIndex];
				LK.getSound(soundData.sound).play();
				this.handleChainSpecialActions(chain.name, chain.currentIndex);
				chain.currentIndex++;
				if (chain.currentIndex >= chain.sounds.length) {
					this.activeChains.splice(i, 1);
				} else {
					chain.nextPlayTime = LK.ticks + chain.sounds[chain.currentIndex].delay;
				}
			}
		}
	},
	handleChainSpecialActions: function handleChainSpecialActions(chainName, soundIndex) {
		if (chainName === 'flyingWave4Chain' && soundIndex === 6) {
			spawnFexEnemy();
		}
	}
};

===================================================================
--- original.js
+++ change.js
@@ -928,9 +928,9 @@
 			// Show mercy message when vex enemy appears
 			if (!self.mercyMessageShown) {
 				self.mercyMessageShown = true;
 				// Create mercy message text
-				var mercyText = new Text2("have mercy on that soldier and ungrade him", {
+				var mercyText = new Text2("o askere merhamet et ve onu yükselt", {
 					size: 80,
 					fill: 0xFFFFFF,
 					weight: 800
 				});