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

/**** 
* Classes
****/ 
var BuildSpot = Container.expand(function (spotNumber) {
	var self = Container.call(this);
	var spotGraphics = self.attachAsset('buildSpot', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.occupied = false;
	self.spotNumber = spotNumber || 0;
	// Build spot graphic only, no number display
	self.down = function (x, y, obj) {
		console.log("Build spot", self.spotNumber, "clicked, occupied:", self.occupied, "showingBuildMenu:", showingBuildMenu);
		if (!self.occupied && !showingBuildMenu) {
			console.log("Showing build menu for spot", self.spotNumber, "at:", self.x, self.y);
			showBuildMenu(self);
		}
	};
	return self;
});
var Bullet = Container.expand(function (startX, startY, target, damage, towerType, specialData) {
	var self = Container.call(this);
	// Choose random bullet asset from all available types
	var bulletTypes = ['bullet', 'drumBullet', 'trumpetBullet', 'guitarBullet', 'violinBullet', 'djBullet'];
	var bulletAsset = bulletTypes[Math.floor(Math.random() * bulletTypes.length)];
	var bulletGraphics = self.attachAsset(bulletAsset, {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.x = startX;
	self.y = startY;
	self.target = target;
	self.damage = damage;
	self.speed = 8;
	self.towerType = towerType || 'drum';
	self.specialData = specialData || {};
	self.hitTargets = []; // For chain attacks
	self.update = function () {
		if (!self.target || self.target.health <= 0) {
			self.destroy();
			return;
		}
		var dx = self.target.x - self.x;
		var dy = self.target.y - self.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		if (distance < 20) {
			// Hit target
			var died = false;
			// Handle different tower effects
			if (self.towerType === 'drum') {
				// Area damage around target
				died = self.target.takeDamage(self.damage);
				// Damage other enemies in area
				for (var i = 0; i < enemies.length; i++) {
					var enemy = enemies[i];
					if (enemy !== self.target) {
						var dx2 = enemy.x - self.target.x;
						var dy2 = enemy.y - self.target.y;
						var areaDist = Math.sqrt(dx2 * dx2 + dy2 * dy2);
						if (areaDist <= (self.specialData.areaRadius || 60)) {
							enemy.takeDamage(self.damage);
							// Level III drum tower slow effect
							if (self.specialData.slowEffect && Math.random() < (self.specialData.slowChance || 0.1)) {
								enemy.slowedUntil = LK.ticks + (self.specialData.slowDuration || 90);
							}
						}
					}
				}
			} else if (self.towerType === 'trumpet') {
				// Damage and pushback
				died = self.target.takeDamage(self.damage);
				// Apply pushback effect
				if (!died && self.target.pathIndex < pathPoints.length - 2) {
					self.target.pathIndex = Math.max(0, self.target.pathIndex - 1);
				}
				// Level III stun effect
				if (!died && self.specialData.stunChance && Math.random() < self.specialData.stunChance) {
					self.target.stunnedUntil = LK.ticks + (self.specialData.stunDuration || 60);
					// Visual stun effect
					var enemyGraphics = self.target.getChildAt(0);
					if (enemyGraphics) {
						var originalTint = enemyGraphics.tint || 0xffffff;
						tween(enemyGraphics, {
							tint: 0xFFFF00,
							// Yellow stun effect
							scaleX: 0.8,
							scaleY: 0.8
						}, {
							duration: 200,
							easing: tween.easeOut,
							onFinish: function onFinish() {
								LK.setTimeout(function () {
									if (enemyGraphics && enemyGraphics.parent) {
										tween(enemyGraphics, {
											tint: originalTint,
											scaleX: 1.0,
											scaleY: 1.0
										}, {
											duration: 300
										});
									}
								}, (self.specialData.stunDuration || 60) * 16);
							}
						});
					}
				}
			} else if (self.towerType === 'guitar') {
				// Chain attack with multiple hits
				var hitsPerTarget = 3; // Guitar does 3 hits per target
				for (var hit = 0; hit < hitsPerTarget; hit++) {
					died = self.target.takeDamage(self.damage) || died;
				}
				self.hitTargets.push(self.target);
				var chainsLeft = (self.specialData.chainCount || 3) - self.hitTargets.length;
				if (chainsLeft > 0) {
					// Find next target for chain
					var nextTarget = null;
					var closestDist = 150; // Chain range
					for (var i = 0; i < enemies.length; i++) {
						var enemy = enemies[i];
						if (self.hitTargets.indexOf(enemy) === -1 && enemy.health > 0) {
							var dx2 = enemy.x - self.target.x;
							var dy2 = enemy.y - self.target.y;
							var chainDist = Math.sqrt(dx2 * dx2 + dy2 * dy2);
							if (chainDist < closestDist) {
								nextTarget = enemy;
								closestDist = chainDist;
							}
						}
					}
					if (nextTarget) {
						self.target = nextTarget;
						return; // Continue to next target
					}
					// Level III extended chaining
					else if (self.specialData.extendedChain && self.hitTargets.length === self.specialData.chainCount) {
						// Try to find enemies near the last hit target for extended chain
						var lastTarget = self.hitTargets[self.hitTargets.length - 1];
						for (var i = 0; i < enemies.length; i++) {
							var enemy = enemies[i];
							if (self.hitTargets.indexOf(enemy) === -1 && enemy.health > 0) {
								var dx2 = enemy.x - lastTarget.x;
								var dy2 = enemy.y - lastTarget.y;
								var chainDist = Math.sqrt(dx2 * dx2 + dy2 * dy2);
								if (chainDist < 100) {
									// Shorter range for extended chain
									self.target = enemy;
									self.specialData.chainCount++; // Extend the chain
									return;
								}
							}
						}
					}
				}
			} else if (self.towerType === 'violin') {
				// Damage with slow and freeze chance
				died = self.target.takeDamage(self.damage);
				// Check for freeze effect first (Level III only)
				var froze = false;
				if (!died && self.specialData.freezeChance && Math.random() < self.specialData.freezeChance) {
					self.target.frozenUntil = LK.ticks + (self.specialData.freezeDuration || 90);
					froze = true;
					// Apply freeze animation
					var enemyGraphics = self.target.getChildAt(0);
					if (enemyGraphics) {
						var originalTint = enemyGraphics.tint || 0xffffff;
						tween(enemyGraphics, {
							tint: 0x00FFFF,
							// Cyan freeze effect
							scaleX: 0.9,
							scaleY: 0.9,
							alpha: 0.7
						}, {
							duration: 200,
							easing: tween.easeOut,
							onFinish: function onFinish() {
								LK.setTimeout(function () {
									if (enemyGraphics && enemyGraphics.parent) {
										tween(enemyGraphics, {
											tint: originalTint,
											scaleX: 1.0,
											scaleY: 1.0,
											alpha: 1.0
										}, {
											duration: 300
										});
									}
								}, (self.specialData.freezeDuration || 90) * 16);
							}
						});
					}
				}
				// Apply slow effect if not frozen
				else if (!died && !froze && Math.random() < (self.specialData.slowChance || 0.25)) {
					self.target.slowedUntil = LK.ticks + (self.specialData.slowDuration || 120);
					// Apply freeze animation - enemy becomes frozen and shimmers
					var enemyGraphics = self.target.getChildAt(0);
					if (enemyGraphics) {
						// Store original values
						var originalTint = enemyGraphics.tint || 0xffffff;
						var originalScaleX = enemyGraphics.scaleX || 1.0;
						var originalScaleY = enemyGraphics.scaleY || 1.0;
						var originalAlpha = enemyGraphics.alpha || 1.0;
						// Freeze effect with ice-blue tint and slight scale animation
						tween(enemyGraphics, {
							tint: 0x0080FF,
							scaleX: originalScaleX * 1.1,
							scaleY: originalScaleY * 1.1,
							alpha: 0.8
						}, {
							duration: 300,
							easing: tween.easeOut
						});
						// Shimmer effect during freeze duration
						var shimmerCount = 0;
						var maxShimmers = Math.floor((self.specialData.slowDuration || 120) / 30);
						var _doShimmer = function doShimmer() {
							if (shimmerCount < maxShimmers && self.target && self.target.slowedUntil && LK.ticks < self.target.slowedUntil) {
								tween(enemyGraphics, {
									alpha: 0.5,
									tint: 0xB3D9FF
								}, {
									duration: 300,
									easing: tween.easeInOut,
									onFinish: function onFinish() {
										tween(enemyGraphics, {
											alpha: 0.8,
											tint: 0x0080FF
										}, {
											duration: 300,
											easing: tween.easeInOut,
											onFinish: function onFinish() {
												shimmerCount++;
												if (shimmerCount < maxShimmers) {
													LK.setTimeout(_doShimmer, 100);
												}
											}
										});
									}
								});
							}
						};
						LK.setTimeout(_doShimmer, 300);
						// Return to normal after freeze duration
						LK.setTimeout(function () {
							if (enemyGraphics && enemyGraphics.parent) {
								tween(enemyGraphics, {
									tint: originalTint,
									scaleX: originalScaleX,
									scaleY: originalScaleY,
									alpha: originalAlpha
								}, {
									duration: 500
								});
							}
						}, (self.specialData.slowDuration || 120) * 16);
					}
				}
			} else if (self.towerType === 'dj') {
				// Area damage with blind effect and Level III distortion
				died = self.target.takeDamage(self.damage);
				// Damage and apply effects to other enemies in large area
				for (var i = 0; i < enemies.length; i++) {
					var enemy = enemies[i];
					var dx2 = enemy.x - self.target.x;
					var dy2 = enemy.y - self.target.y;
					var areaDist = Math.sqrt(dx2 * dx2 + dy2 * dy2);
					if (areaDist <= (self.specialData.areaRadius || 120)) {
						if (enemy !== self.target) {
							enemy.takeDamage(self.damage * 0.8); // Reduced area damage
						}
						// Apply blind effect (reduce speed)
						enemy.blindedUntil = LK.ticks + (self.specialData.blindDuration || 60);
						// Level III distortion effect
						if (self.specialData.distortionEffect) {
							enemy.distortedUntil = LK.ticks + (self.specialData.distortionDuration || 180);
							enemy.distortionDamage = self.specialData.distortionDamage || 5;
							enemy.distortionSlowPercent = self.specialData.distortionSlowPercent || 0.25;
							// Visual distortion effect
							var enemyGraphics = enemy.getChildAt(0);
							if (enemyGraphics) {
								tween(enemyGraphics, {
									tint: 0xFF00FF,
									// Magenta distortion effect
									rotation: 0.2
								}, {
									duration: 300,
									easing: tween.easeOut
								});
							}
						}
					}
				}
			} else {
				// Default damage
				died = self.target.takeDamage(self.damage);
			}
			if (died) {
				// Calculate gold reward with restrictions
				var goldReward = self.target.goldValue;
				// Reduce gold per enemy from wave 6
				if (wave >= 6) {
					goldReward = Math.min(goldReward, 3);
				}
				// Ensure minimum gold reward of 1 for all enemies from wave 10+
				if (wave >= 10 && goldReward === 0) {
					goldReward = 1;
				}
				// Check wave gold limit
				if (lastWaveGoldEarned + goldReward > maxGoldPerWave) {
					goldReward = Math.max(1, maxGoldPerWave - lastWaveGoldEarned);
				}
				// Apply gold reward
				if (goldReward > 0) {
					gold += goldReward;
					lastWaveGoldEarned += goldReward;
				}
				updateUI();
				LK.getSound('enemyDeath').play();
			}
			self.destroy();
		} else {
			self.x += dx / distance * self.speed;
			self.y += dy / distance * self.speed;
		}
	};
	return self;
});
var Enemy = Container.expand(function (enemyType, isElite, isSpecial, specialType) {
	var self = Container.call(this);
	// Set enemy properties based on type
	self.enemyType = enemyType || 'notaDesafinada';
	self.isElite = isElite || false;
	self.isSpecial = isSpecial || false;
	self.specialType = specialType || '';
	var assetName = self.isElite ? 'eliteEnemy' : self.enemyType;
	var enemyGraphics = self.attachAsset(assetName, {
		anchorX: 0.5,
		anchorY: 0.5
	});
	if (self.enemyType === 'notaDesafinada') {
		self.health = 90;
		self.maxHealth = 90;
		self.speed = 2;
		self.goldValue = 5;
	} else if (self.enemyType === 'ruidoBlanco') {
		self.health = 144;
		self.maxHealth = 144;
		self.speed = 1.2;
		self.goldValue = 8;
	} else if (self.enemyType === 'glitchAudio') {
		self.health = 72;
		self.maxHealth = 72;
		self.speed = 2.7; // Further reduced for better balance when empowered
		self.goldValue = 6;
	} else if (self.enemyType === 'ecoOscuro') {
		self.health = 180;
		self.maxHealth = 180;
		self.speed = 2;
		self.goldValue = 12;
		self.canSplit = true;
	} else if (self.enemyType === 'autotuneMalicioso') {
		self.health = 270;
		self.maxHealth = 270;
		self.speed = 1.8;
		self.goldValue = 20;
		self.debuffRadius = 100;
	}
	// Elite enemies have double HP and gold value
	if (self.isElite) {
		self.health *= 2;
		self.maxHealth *= 2;
		self.goldValue *= 2;
		enemyGraphics.scaleX = 1.3;
		enemyGraphics.scaleY = 1.3;
	}
	// Special enemy modifications
	if (self.isSpecial) {
		if (self.specialType === 'spectral') {
			self.goldValue = 0; // No gold reward
			enemyGraphics.tint = 0x8800FF; // Purple tint
			enemyGraphics.alpha = 0.7;
		} else if (self.specialType === 'runner') {
			self.speed *= 2.5; // Very fast
			self.health *= 0.5; // Low health
			enemyGraphics.tint = 0x00FFFF; // Cyan tint
		} else if (self.specialType === 'armored') {
			self.health *= 1.8; // High health
			self.speed *= 0.7; // Slower
			self.damageResistance = 0.3; // 30% damage reduction
			enemyGraphics.tint = 0x808080; // Gray tint
		} else if (self.specialType === 'explosive') {
			self.explosiveDamage = 25;
			self.explosiveRadius = 80;
			enemyGraphics.tint = 0xFF4400; // Orange-red tint
		} else if (self.specialType === 'disruptor') {
			self.disruptRadius = 100;
			enemyGraphics.tint = 0xFFFF00; // Yellow tint
		}
	}
	self.pathIndex = 0;
	self.walkAnimationTimer = 0;
	self.originalScale = 1.0;
	self.takeDamage = function (damage) {
		// Apply damage resistance for armored enemies
		if (self.isSpecial && self.specialType === 'armored' && self.damageResistance) {
			damage *= 1 - self.damageResistance;
		}
		self.health -= damage;
		if (self.health <= 0) {
			self.health = 0;
			// Special enemy death effects
			if (self.isSpecial) {
				if (self.specialType === 'explosive') {
					// Damage nearby towers
					for (var i = 0; i < towers.length; i++) {
						var tower = towers[i];
						var dx = tower.x - self.x;
						var dy = tower.y - self.y;
						var distance = Math.sqrt(dx * dx + dy * dy);
						if (distance <= self.explosiveRadius) {
							tower.disruptedUntil = LK.ticks + 120; // 2 seconds disruption
							// Visual explosion effect
							var explosion = game.addChild(LK.getAsset('spotlight', {
								anchorX: 0.5,
								anchorY: 0.5
							}));
							explosion.x = self.x;
							explosion.y = self.y;
							explosion.tint = 0xFF4400;
							explosion.alpha = 0.8;
							tween(explosion, {
								scaleX: 3,
								scaleY: 3,
								alpha: 0
							}, {
								duration: 500,
								onFinish: function onFinish() {
									explosion.destroy();
								}
							});
						}
					}
				}
			}
			// Handle splitting for Eco Oscuro
			if (self.enemyType === 'ecoOscuro' && self.canSplit) {
				// Create two Nota Desafinada enemies
				for (var i = 0; i < 2; i++) {
					var splitEnemy = new Enemy('notaDesafinada');
					splitEnemy.x = self.x + (i === 0 ? -30 : 30);
					splitEnemy.y = self.y;
					splitEnemy.pathIndex = self.pathIndex;
					enemies.push(splitEnemy);
					game.addChild(splitEnemy);
				}
			}
			return true; // Enemy died
		}
		// Flash red when hit but preserve original tint
		var originalTint = enemyGraphics.tint;
		tween(enemyGraphics, {
			tint: 0xff0000
		}, {
			duration: 100,
			onFinish: function onFinish() {
				tween(enemyGraphics, {
					tint: originalTint
				}, {
					duration: 100
				});
			}
		});
		return false;
	};
	self.update = function () {
		// Enhanced walking animation - more pronounced feet movement and body oscillation
		self.walkAnimationTimer += 0.4; // Increased animation speed
		var walkBob = Math.sin(self.walkAnimationTimer) * 0.12; // More pronounced bobbing
		var walkSway = Math.cos(self.walkAnimationTimer * 0.9) * 0.05; // Increased sway
		var footStep = Math.sin(self.walkAnimationTimer * 2) * 0.08; // Foot stepping animation
		// Enhanced scale animation for walking feet effect
		enemyGraphics.scaleY = self.originalScale + walkBob + footStep;
		enemyGraphics.scaleX = self.originalScale + walkBob * 0.4 + Math.abs(footStep) * 0.2;
		// Enhanced rotation for body sway during movement
		enemyGraphics.rotation = Math.sin(self.walkAnimationTimer * 1.4) * 0.06 + walkSway;
		// Add slight vertical movement for walking bounce
		enemyGraphics.y = Math.sin(self.walkAnimationTimer * 1.8) * 3;
		// Additional movement for floating/spectral enemies
		if (self.isSpecial && self.specialType === 'spectral') {
			enemyGraphics.y = Math.sin(self.walkAnimationTimer * 0.6) * 20; // Increased floating range
			enemyGraphics.rotation += Math.sin(self.walkAnimationTimer * 0.4) * 0.15; // More rotation
			enemyGraphics.alpha = 0.7 + Math.sin(self.walkAnimationTimer * 0.8) * 0.1; // Ghostly flickering
		}
		if (self.pathIndex < pathPoints.length - 1) {
			var targetPoint = pathPoints[self.pathIndex + 1];
			var dx = targetPoint.x - self.x;
			var dy = targetPoint.y - self.y;
			var distance = Math.sqrt(dx * dx + dy * dy);
			if (distance < 10) {
				self.pathIndex++;
				if (self.pathIndex >= pathPoints.length - 1) {
					// Reached goal - play portal sound and animate enemy entering portal
					LK.getSound('portal').play();
					// Animate enemy being sucked into portal
					tween(self, {
						x: goal.x,
						y: goal.y,
						scaleX: 0.2,
						scaleY: 0.2,
						rotation: Math.PI * 4
					}, {
						duration: 500,
						easing: tween.easeIn,
						onFinish: function onFinish() {
							// Final disappearing effect
							tween(self, {
								alpha: 0,
								scaleX: 0.05,
								scaleY: 0.05
							}, {
								duration: 200,
								easing: tween.easeIn,
								onFinish: function onFinish() {
									lives--;
									updateUI();
									if (lives <= 0) {
										LK.showGameOver();
									}
									// Remove enemy from array and destroy
									var enemyIndex = enemies.indexOf(self);
									if (enemyIndex > -1) {
										enemies.splice(enemyIndex, 1);
									}
									self.destroy();
								}
							});
						}
					});
					return; // Exit update to prevent further movement
				}
			} else {
				// Calculate current speed with effects
				var currentSpeed = self.speed;
				// Apply stun effect from trumpet (completely stops movement)
				if (self.stunnedUntil && LK.ticks < self.stunnedUntil) {
					currentSpeed = 0; // Can't move when stunned
				}
				// Apply Grand Piano stun effect (completely stops movement)
				else if (self.grandPianoStunnedUntil && LK.ticks < self.grandPianoStunnedUntil) {
					currentSpeed = 0; // Can't move when stunned by Grand Piano
				}
				// Apply freeze effect from violin (completely stops movement)
				else if (self.frozenUntil && LK.ticks < self.frozenUntil) {
					currentSpeed = 0; // Can't move when frozen
				}
				// Apply slow effect from violin
				else if (self.slowedUntil && LK.ticks < self.slowedUntil) {
					currentSpeed *= 0.5; // 50% speed when slowed
				}
				// Apply blind effect from DJ (further speed reduction)
				if (self.blindedUntil && LK.ticks < self.blindedUntil) {
					currentSpeed *= 0.3; // 30% speed when blinded
				}
				// Apply distortion effect from DJ Level III
				if (self.distortedUntil && LK.ticks < self.distortedUntil) {
					currentSpeed *= 1 - (self.distortionSlowPercent || 0.25); // Additional slow from distortion
					// Apply DoT damage every 30 ticks (0.5 seconds)
					if (LK.ticks % 30 === 0) {
						self.takeDamage(self.distortionDamage || 5);
					}
				}
				// Apply autotune debuff to nearby towers
				if (self.enemyType === 'autotuneMalicioso') {
					for (var i = 0; i < towers.length; i++) {
						var tower = towers[i];
						var dx2 = tower.x - self.x;
						var dy2 = tower.y - self.y;
						var towerDist = Math.sqrt(dx2 * dx2 + dy2 * dy2);
						if (towerDist <= self.debuffRadius) {
							tower.debuffedUntil = LK.ticks + 1; // Continuous debuff while in range
						}
					}
				}
				// Special disruptor enemy abilities
				if (self.isSpecial && self.specialType === 'disruptor') {
					for (var i = 0; i < towers.length; i++) {
						var tower = towers[i];
						var dx2 = tower.x - self.x;
						var dy2 = tower.y - self.y;
						var towerDist = Math.sqrt(dx2 * dx2 + dy2 * dy2);
						if (towerDist <= self.disruptRadius) {
							tower.disruptedUntil = LK.ticks + 1; // Continuous disruption
						}
					}
				}
				self.x += dx / distance * currentSpeed;
				self.y += dy / distance * currentSpeed;
			}
		}
	};
	return self;
});
var Tower = Container.expand(function (towerType) {
	var self = Container.call(this);
	self.towerType = towerType || 'drum';
	var assetName = self.towerType + 'Tower';
	var towerGraphics = self.attachAsset(assetName, {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Function to update tower graphics based on level
	self.updateTowerGraphics = function () {
		var newAssetName;
		if (self.level === 1) {
			newAssetName = self.towerType + 'Tower';
		} else if (self.level === 2) {
			if (self.towerType === 'drum') newAssetName = 'Tambor2';else if (self.towerType === 'trumpet') newAssetName = 'Trompeta2';else if (self.towerType === 'guitar') newAssetName = 'Guitarra2';else if (self.towerType === 'violin') newAssetName = 'Violin2';else if (self.towerType === 'dj') newAssetName = 'DJ2';
		} else if (self.level === 3) {
			if (self.towerType === 'drum') newAssetName = 'Tambor3';else if (self.towerType === 'trumpet') newAssetName = 'Trompeta3';else if (self.towerType === 'guitar') newAssetName = 'Guitarra3';else if (self.towerType === 'violin') newAssetName = 'Violin3';else if (self.towerType === 'dj') newAssetName = 'DJ3';
		}
		// Remove old graphics and add new ones
		if (towerGraphics && towerGraphics.parent) {
			self.removeChild(towerGraphics);
		}
		towerGraphics = self.attachAsset(newAssetName, {
			anchorX: 0.5,
			anchorY: 0.5
		});
	};
	// Tower level system
	self.level = 1;
	self.totalCost = 0; // Track total investment for removal refund
	// Tower properties based on type
	if (self.towerType === 'drum') {
		self.damage = 15;
		self.range = 165; // Short range
		self.fireRate = 30; // Fast (0.5s at 60fps)
		self.cost = 50;
		self.areaRadius = 60; // Small area for drum
	} else if (self.towerType === 'trumpet') {
		self.damage = 35;
		self.range = 180; // Medium range
		self.fireRate = 60; // Medium (1s at 60fps)
		self.cost = 80;
		self.pushback = true;
	} else if (self.towerType === 'guitar') {
		self.damage = 20;
		self.range = 220; // Long range
		self.fireRate = 90; // Slow (1.5s at 60fps)
		self.cost = 120;
		self.chainCount = 3;
	} else if (self.towerType === 'violin') {
		self.damage = 10;
		self.range = 220; // Long range
		self.fireRate = 60; // Medium (1s at 60fps)
		self.cost = 100;
		self.slowChance = 0.25; // 25% chance
		self.slowDuration = 120; // 2s at 60fps
	} else if (self.towerType === 'dj') {
		self.damage = 50;
		self.range = 200; // Large area
		self.fireRate = 150; // Very slow (2.5s at 60fps)
		self.cost = 200;
		self.areaRadius = 120; // Large area
		self.blindEffect = true;
	}
	// Store base stats for upgrade calculations
	self.baseDamage = self.damage;
	self.baseRange = self.range;
	self.baseFireRate = self.fireRate;
	self.baseAreaRadius = self.areaRadius || 0;
	self.totalCost = self.cost; // Track total investment
	self.lastFire = self.fireRate; // Initialize to fireRate to allow immediate first shot after properties are set
	self.findTarget = function () {
		var closestEnemy = null;
		var closestDistance = self.range;
		for (var i = 0; i < enemies.length; i++) {
			var enemy = enemies[i];
			var dx = enemy.x - self.x;
			var dy = enemy.y - self.y;
			var distance = Math.sqrt(dx * dx + dy * dy);
			if (distance <= self.range && distance < closestDistance) {
				closestEnemy = enemy;
				closestDistance = distance;
			}
		}
		return closestEnemy;
	};
	self.fire = function (target) {
		var specialData = {
			areaRadius: self.areaRadius,
			chainCount: self.chainCount,
			slowChance: self.slowChance,
			slowDuration: self.slowDuration
		};
		// Apply autotune debuff if present
		var actualDamage = self.damage;
		if (self.debuffedUntil && LK.ticks < self.debuffedUntil) {
			actualDamage *= 0.8; // 20% damage reduction
		}
		var bullet = new Bullet(self.x, self.y, target, actualDamage, self.towerType, specialData);
		bullets.push(bullet);
		game.addChild(bullet);
		// Play specific sound for different tower types
		if (self.towerType === 'trumpet') {
			LK.getSound('proyectilT').play();
		} else if (self.towerType === 'drum') {
			try {
				LK.getSound('ProyectilTA').play();
			} catch (error) {
				console.log("Error playing drum sound, using fallback");
				LK.getSound('hit').play();
			}
		} else if (self.towerType === 'guitar') {
			LK.getSound('ProyectilG').play();
		} else if (self.towerType === 'violin') {
			LK.getSound('ProyectilV').play();
		} else if (self.towerType === 'dj') {
			LK.getSound('ProyectilDJ').play();
		} else {
			LK.getSound('hit').play();
		}
	};
	// Tower upgrade method with specific stats per tower type and level
	self.upgrade = function () {
		if (self.level >= 3) return false; // Max level reached
		// Calculate upgrade cost based on tower type and level
		var upgradeCost = 0;
		if (self.towerType === 'drum') {
			upgradeCost = self.level === 1 ? 90 : 160;
		} else if (self.towerType === 'trumpet') {
			upgradeCost = self.level === 1 ? 130 : 200;
		} else if (self.towerType === 'guitar') {
			upgradeCost = self.level === 1 ? 180 : 250;
		} else if (self.towerType === 'violin') {
			upgradeCost = self.level === 1 ? 160 : 220;
		} else if (self.towerType === 'dj') {
			upgradeCost = self.level === 1 ? 280 : 350;
		}
		if (gold < upgradeCost) return false; // Not enough gold
		gold -= upgradeCost;
		self.totalCost += upgradeCost;
		self.level++;
		// Apply specific stats based on tower type and level
		if (self.towerType === 'drum') {
			if (self.level === 2) {
				self.damage = 20;
				self.fireRate = 30; // Same as level 1 (0.5s)
				self.areaRadius = Math.floor(self.baseAreaRadius * 1.25); // 25% larger area
			} else if (self.level === 3) {
				self.damage = 25;
				self.fireRate = 24; // 0.4s at 60fps
				self.areaRadius = Math.floor(self.baseAreaRadius * 1.25);
				self.slowEffect = true; // Add 10% slow for 1.5s
				self.slowChance = 0.1;
				self.slowDuration = 90; // 1.5s at 60fps
			}
		} else if (self.towerType === 'trumpet') {
			if (self.level === 2) {
				self.damage = 45;
				self.fireRate = 54; // 0.9s at 60fps
				self.strongerPushback = true;
			} else if (self.level === 3) {
				self.damage = 60;
				self.fireRate = 48; // 0.8s at 60fps
				self.stunChance = 0.1; // 10% stun chance
				self.stunDuration = 60; // 1s at 60fps
			}
		} else if (self.towerType === 'guitar') {
			if (self.level === 2) {
				self.damage = 25; // Per hit
				self.fireRate = 78; // 1.3s at 60fps
				self.chainCount = 4;
			} else if (self.level === 3) {
				self.damage = 30; // Per hit
				self.fireRate = 72; // 1.2s at 60fps
				self.chainCount = 4;
				self.extendedChain = true; // Enhanced chaining
			}
		} else if (self.towerType === 'violin') {
			if (self.level === 2) {
				self.damage = 14;
				self.fireRate = 60; // Same as level 1 (1.0s)
				self.slowChance = 0.35; // 35% slow
				self.slowDuration = 180; // 3s at 60fps
			} else if (self.level === 3) {
				self.damage = 18;
				self.fireRate = 54; // 0.9s at 60fps
				self.slowChance = 0.40; // 40% slow
				self.slowDuration = 180;
				self.freezeChance = 0.1; // 10% freeze chance
				self.freezeDuration = 90; // 1.5s at 60fps
			}
		} else if (self.towerType === 'dj') {
			if (self.level === 2) {
				self.damage = 65;
				self.fireRate = 138; // 2.3s at 60fps
				self.areaRadius = Math.floor(self.baseAreaRadius * 1.2); // Larger area
				self.blindDuration = 60; // 1s blind
			} else if (self.level === 3) {
				self.damage = 80;
				self.fireRate = 120; // 2.0s at 60fps
				self.distortionEffect = true; // Add distortion (25% slow + DoT)
				self.distortionSlowPercent = 0.25;
				self.distortionDamage = 5; // DoT damage per tick
				self.distortionDuration = 180; // 3s duration
			}
		}
		// Update tower graphics to show new level
		self.updateTowerGraphics();
		// Light animation effect without changing tower color
		var lightEffect = self.addChild(LK.getAsset('spotlight', {
			anchorX: 0.5,
			anchorY: 0.5
		}));
		lightEffect.x = 0;
		lightEffect.y = 0;
		lightEffect.scaleX = 2;
		lightEffect.scaleY = 2;
		lightEffect.alpha = 0.8;
		lightEffect.tint = 0xFFD700; // Gold light effect
		tween(lightEffect, {
			scaleX: 3,
			scaleY: 3,
			alpha: 0
		}, {
			duration: 1000,
			easing: tween.easeOut,
			onFinish: function onFinish() {
				lightEffect.destroy();
			}
		});
		updateUI();
		return true;
	};
	// Tower click handler for upgrade menu
	self.down = function (x, y, obj) {
		if (!showingBuildMenu && gameState === 'playing') {
			// If this tower is already selected and upgrade menu is showing, close it
			if (showingUpgradeMenu && selectedTower === self) {
				hideUpgradeMenu();
			} else {
				// Otherwise show upgrade menu for this tower
				showUpgradeMenu(self);
			}
		}
	};
	self.update = function () {
		self.lastFire++;
		// Check if tower is disrupted
		if (self.disruptedUntil && LK.ticks < self.disruptedUntil) {
			return; // Skip firing if disrupted
		}
		if (self.lastFire >= self.fireRate) {
			var target = self.findTarget();
			if (target && target.health > 0) {
				self.fire(target);
				self.lastFire = 0;
				// Add visual firing effect
				tween(towerGraphics, {
					scaleX: 1.2,
					scaleY: 1.2
				}, {
					duration: 100,
					onFinish: function onFinish() {
						tween(towerGraphics, {
							scaleX: 1.0,
							scaleY: 1.0
						}, {
							duration: 100
						});
					}
				});
			}
		}
	};
	return self;
});

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

/**** 
* Game Code
****/ 
// Game variables
var gameState = 'menu'; // 'menu', 'tutorial', 'playing'
var tutorialStep = 0;
var menuContainer;
var tutorialContainer;
// Difficulty system variables
var goldPerEnemy = 5; // Base gold per enemy
var maxGoldPerWave = 60; // Base maximum gold per wave
var goldAbuseCooldown = 0; // Timer for gold abuse punishment
var highGoldWaveCount = 0; // Count of waves with excess gold
var lastWaveGoldEarned = 0; // Track gold earned in current wave
var difficultyModifier = 1.0; // Applied to enemy stats for punishment
var enemySpeedModifier = 1.0; // Speed increase from wave 10+
var forceExpenseEvent = false; // Force expense event flag
var nextForceExpenseWave = 5; // Next wave to force expense
var currentSpecialWave = null; // Track current special wave type
// Simple music system - just track if Melodia is playing
var gameplayMusicPlaying = false; // Flag to track if music is currently playing
// Game Elements
var enemies = [];
var towers = [];
var bullets = [];
var buildSpots = [];
var gold = 150;
var lives = 20;
var wave = 1;
var enemiesSpawned = 0;
var enemiesPerWave = 10;
var spawnTimer = 0;
var waveStarted = false;
var wavePaused = true; // New: waves start paused between waves
var autoStartTimer = 0; // New: timer for auto-starting waves
var showingBuildMenu = false;
var selectedBuildSpot = null;
var backgroundElements = [];
var floatingNotes = [];
// Tower upgrade system variables
var showingUpgradeMenu = false;
var selectedTower = null;
var upgradeMenuContainer;
// Credits screen variables
var creditsContainer;
var showingCredits = false;
// Grand Piano Power System
var grandPianoPowerUnlocked = false;
var grandPianoCooldownRemaining = 0;
var grandPianoPowerButton;
var grandPianoPowerText;
var grandPianoCooldownText;
var grandPianoButtonBackground;
var grandPianoPowerActive = false;
var grandPianoGhostMode = false;
var grandPianoGhost = null;
var grandPianoTargetArea = null;
var grandPianoUnlockAnimationShown = false;
// === GIANT WOODEN TABLE BACKGROUND ===
// Create a large wooden table that covers the entire game area as the base
var giantTable = game.addChild(LK.getAsset('woodPanel', {
	anchorX: 0.5,
	anchorY: 0.5
}));
giantTable.x = 1024;
giantTable.y = 1366;
giantTable.scaleX = 5.0; // Scale to cover full width
giantTable.scaleY = 6.0; // Scale to cover full height
giantTable.tint = 0x8B4513; // Rich wooden brown color
giantTable.alpha = 0.3; // Semi-transparent so other elements are visible
backgroundElements.push(giantTable);
// === STAGE AREA (Top section of concert hall) ===
// Main stage backdrop
var stage = game.addChild(LK.getAsset('stage', {
	anchorX: 0.5,
	anchorY: 1
}));
stage.x = 1024;
stage.y = 350;
stage.scaleX = 0.9;
stage.scaleY = 0.8;
backgroundElements.push(stage);
// Stage curtain backdrop
var stageBackdrop = game.addChild(LK.getAsset('curtain', {
	anchorX: 0.5,
	anchorY: 0
}));
stageBackdrop.x = 1024;
stageBackdrop.y = 30;
stageBackdrop.scaleX = 1.2;
stageBackdrop.scaleY = 0.7;
backgroundElements.push(stageBackdrop);
// Orchestra pit and performance area
var orchestraPit = game.addChild(LK.getAsset('orchestraPit', {
	anchorX: 0.5,
	anchorY: 1
}));
orchestraPit.x = 1024;
orchestraPit.y = 550;
orchestraPit.scaleX = 0.8;
orchestraPit.scaleY = 0.6;
backgroundElements.push(orchestraPit);
// Grand piano in orchestra pit
var grandPiano = game.addChild(LK.getAsset('grandPiano', {
	anchorX: 0.5,
	anchorY: 0.5
}));
grandPiano.x = 900;
grandPiano.y = 400;
grandPiano.scaleX = 0.8;
grandPiano.scaleY = 0.8;
backgroundElements.push(grandPiano);
// Conductor podium
var conductor = game.addChild(LK.getAsset('conductor', {
	anchorX: 0.5,
	anchorY: 1
}));
conductor.x = 1024;
conductor.y = 420;
conductor.scaleX = 0.8;
conductor.scaleY = 0.8;
backgroundElements.push(conductor);
// Music stands arranged in orchestra pit
for (var i = 0; i < 6; i++) {
	var musicStand = game.addChild(LK.getAsset('musicStand', {
		anchorX: 0.5,
		anchorY: 1
	}));
	musicStand.x = 750 + i * 90;
	musicStand.y = 440;
	musicStand.scaleX = 0.6;
	musicStand.scaleY = 0.8;
	backgroundElements.push(musicStand);
}
// === UPPER BALCONIES AND VIP AREAS ===
// Main balconies positioned logically
for (var i = 0; i < 2; i++) {
	var balcony = game.addChild(LK.getAsset('balcony', {
		anchorX: 0.5,
		anchorY: 0.5
	}));
	balcony.x = 400 + i * 1200;
	balcony.y = 600;
	balcony.scaleX = 0.7;
	balcony.scaleY = 0.6;
	backgroundElements.push(balcony);
	// Royal crests for main balconies
	var crest = game.addChild(LK.getAsset('royalCrest', {
		anchorX: 0.5,
		anchorY: 0.5
	}));
	crest.x = balcony.x;
	crest.y = balcony.y - 60;
	crest.scaleX = 0.5;
	crest.scaleY = 0.5;
	backgroundElements.push(crest);
}
// VIP boxes on middle level
for (var i = 0; i < 3; i++) {
	var vipBox = game.addChild(LK.getAsset('vipBox', {
		anchorX: 0.5,
		anchorY: 0.5
	}));
	vipBox.x = 300 + i * 700;
	vipBox.y = 800;
	vipBox.scaleX = 0.6;
	vipBox.scaleY = 0.5;
	backgroundElements.push(vipBox);
	// VIP box seating removed
}
// === LIGHTING AND ATMOSPHERE ===
// Chandeliers positioned strategically
for (var i = 0; i < 4; i++) {
	var chandelier = game.addChild(LK.getAsset('chandelier', {
		anchorX: 0.5,
		anchorY: 0.5
	}));
	chandelier.x = 400 + i * 400;
	chandelier.y = 120;
	chandelier.scaleX = 0.8;
	chandelier.scaleY = 0.8;
	backgroundElements.push(chandelier);
	// Chandelier swaying animation
	tween(chandelier, {
		rotation: 0.08
	}, {
		duration: 2500,
		easing: tween.easeInOut,
		onFinish: function onFinish() {
			tween(chandelier, {
				rotation: -0.08
			}, {
				duration: 2500,
				easing: tween.easeInOut,
				onFinish: arguments.callee
			});
		}
	});
}
// === STRUCTURAL ELEMENTS ===
// Supporting pillars
var leftPillar = game.addChild(LK.getAsset('pillar', {
	anchorX: 0.5,
	anchorY: 1
}));
leftPillar.x = 200;
leftPillar.y = 1200;
leftPillar.scaleX = 0.6;
leftPillar.scaleY = 1.0;
backgroundElements.push(leftPillar);
var rightPillar = game.addChild(LK.getAsset('pillar', {
	anchorX: 0.5,
	anchorY: 1
}));
rightPillar.x = 1848;
rightPillar.y = 1200;
rightPillar.scaleX = 0.6;
rightPillar.scaleY = 1.0;
backgroundElements.push(rightPillar);
// Decorative archways section removed
// === AUDIENCE SEATING AREAS ===
// Classical concert hall seating arrangement
// Orchestra Level - Main Floor Seating
// Left orchestra section with center aisle
for (var row = 0; row < 8; row++) {
	for (var col = 0; col < 6; col++) {
		var seat = game.addChild(LK.getAsset('seat', {
			anchorX: 0.5,
			anchorY: 0.5
		}));
		seat.x = 300 + col * 65;
		seat.y = 1800 + row * 70;
		seat.scaleX = 0.8;
		seat.scaleY = 0.8;
		seat.rotation = 0.05; // Slight angle toward stage
		backgroundElements.push(seat);
	}
}
// Right orchestra section with center aisle  
for (var row = 0; row < 8; row++) {
	for (var col = 0; col < 6; col++) {
		var seat = game.addChild(LK.getAsset('seat', {
			anchorX: 0.5,
			anchorY: 0.5
		}));
		seat.x = 1400 + col * 65;
		seat.y = 1800 + row * 70;
		seat.scaleX = 0.8;
		seat.scaleY = 0.8;
		seat.rotation = -0.05; // Slight angle toward stage
		backgroundElements.push(seat);
	}
}
// Center orchestra section - split for main aisle
for (var row = 0; row < 6; row++) {
	// Left side of center section
	for (var col = 0; col < 4; col++) {
		var seat = game.addChild(LK.getAsset('seat', {
			anchorX: 0.5,
			anchorY: 0.5
		}));
		seat.x = 750 + col * 65;
		seat.y = 1850 + row * 70;
		seat.scaleX = 0.9;
		seat.scaleY = 0.9;
		backgroundElements.push(seat);
	}
	// Right side of center section  
	for (var col = 0; col < 4; col++) {
		var seat = game.addChild(LK.getAsset('seat', {
			anchorX: 0.5,
			anchorY: 0.5
		}));
		seat.x = 1100 + col * 65;
		seat.y = 1850 + row * 70;
		seat.scaleX = 0.9;
		seat.scaleY = 0.9;
		backgroundElements.push(seat);
	}
}
// Premium front rows - closer to orchestra pit
for (var row = 0; row < 3; row++) {
	for (var col = 0; col < 12; col++) {
		var seat = game.addChild(LK.getAsset('seat', {
			anchorX: 0.5,
			anchorY: 0.5
		}));
		seat.x = 650 + col * 75;
		seat.y = 1650 + row * 70;
		seat.scaleX = 1.0;
		seat.scaleY = 1.0;
		seat.tint = 0xB8860B; // Gold tint for premium seats
		backgroundElements.push(seat);
	}
}
// Mezzanine Level - First Balcony
// Left and right mezzanine sections removed
// Center mezzanine - elevated premium seating
for (var row = 0; row < 4; row++) {
	for (var col = 0; col < 10; col++) {
		var seat = game.addChild(LK.getAsset('seat', {
			anchorX: 0.5,
			anchorY: 0.5
		}));
		seat.x = 750 + col * 70;
		seat.y = 1100 + row * 65;
		seat.scaleX = 0.8;
		seat.scaleY = 0.8;
		seat.tint = 0x8B0000; // Deep red for premium balcony seats
		backgroundElements.push(seat);
	}
}
// Upper Gallery - Third Level
// Compact seating in upper gallery
for (var row = 0; row < 6; row++) {
	for (var col = 0; col < 16; col++) {
		var seat = game.addChild(LK.getAsset('seat', {
			anchorX: 0.5,
			anchorY: 0.5
		}));
		seat.x = 500 + col * 65;
		seat.y = 800 + row * 60;
		seat.scaleX = 0.6;
		seat.scaleY = 0.6;
		// Create perspective effect - chairs get smaller toward back
		var perspectiveScale = 1.0 - row * 0.05;
		seat.scaleX *= perspectiveScale;
		seat.scaleY *= perspectiveScale;
		backgroundElements.push(seat);
	}
}
// Side Box Seats - Elevated positions along walls
// Rear Orchestra - Additional seating toward entrance
for (var row = 0; row < 5; row++) {
	for (var col = 0; col < 14; col++) {
		var seat = game.addChild(LK.getAsset('seat', {
			anchorX: 0.5,
			anchorY: 0.5
		}));
		seat.x = 600 + col * 70;
		seat.y = 2100 + row * 70;
		seat.scaleX = 0.8;
		seat.scaleY = 0.8;
		// Create slight curve effect for better sightlines
		var curveOffset = Math.sin(col / 13 * Math.PI) * 20;
		seat.y += curveOffset;
		backgroundElements.push(seat);
	}
}
// Standing room areas - simulated with smaller seats for atmosphere
// Upper standing gallery
for (var i = 0; i < 20; i++) {
	var standingSpot = game.addChild(LK.getAsset('seat', {
		anchorX: 0.5,
		anchorY: 0.5
	}));
	standingSpot.x = 400 + i * 60;
	standingSpot.y = 650;
	standingSpot.scaleX = 0.3;
	standingSpot.scaleY = 0.3;
	standingSpot.alpha = 0.7;
	standingSpot.tint = 0x696969; // Gray for standing areas
	backgroundElements.push(standingSpot);
}
// === DECORATIVE LIGHTING ===
// Elegant candelabras positioned throughout
for (var i = 0; i < 6; i++) {
	var candelabra = game.addChild(LK.getAsset('candelabra', {
		anchorX: 0.5,
		anchorY: 1
	}));
	candelabra.x = 400 + i * 200;
	candelabra.y = 1600;
	candelabra.scaleX = 0.9;
	candelabra.scaleY = 1.1;
	backgroundElements.push(candelabra);
	// Flickering flame effect
	tween(candelabra, {
		scaleY: 1.15,
		alpha: 0.85
	}, {
		duration: 1000 + Math.random() * 500,
		easing: tween.easeInOut,
		onFinish: function onFinish() {
			tween(candelabra, {
				scaleY: 1.1,
				alpha: 1.0
			}, {
				duration: 1000 + Math.random() * 500,
				easing: tween.easeInOut,
				onFinish: arguments.callee
			});
		}
	});
}
// Wall-mounted lighting
for (var i = 0; i < 4; i++) {
	var wallCandelabra = game.addChild(LK.getAsset('candelabra', {
		anchorX: 0.5,
		anchorY: 0.5
	}));
	wallCandelabra.x = 150;
	wallCandelabra.y = 1000 + i * 300;
	wallCandelabra.scaleX = 0.7;
	wallCandelabra.scaleY = 0.8;
	backgroundElements.push(wallCandelabra);
	var rightWallCandelabra = game.addChild(LK.getAsset('candelabra', {
		anchorX: 0.5,
		anchorY: 0.5
	}));
	rightWallCandelabra.x = 1898;
	rightWallCandelabra.y = 1000 + i * 300;
	rightWallCandelabra.scaleX = 0.7;
	rightWallCandelabra.scaleY = 0.8;
	backgroundElements.push(rightWallCandelabra);
	// Elevated box seats along left wall
	var leftBoxSeat = game.addChild(LK.getAsset('vipBox', {
		anchorX: 1,
		anchorY: 0.5
	}));
	leftBoxSeat.x = 300;
	leftBoxSeat.y = 1000 + i * 300;
	leftBoxSeat.scaleX = 0.4;
	leftBoxSeat.scaleY = 0.3;
	leftBoxSeat.rotation = 0.1;
	backgroundElements.push(leftBoxSeat);
	// Premium seats inside left box removed
	// Elevated box seats along right wall
	var rightBoxSeat = game.addChild(LK.getAsset('vipBox', {
		anchorX: 0,
		anchorY: 0.5
	}));
	rightBoxSeat.x = 1748;
	rightBoxSeat.y = 1000 + i * 300;
	rightBoxSeat.scaleX = 0.4;
	rightBoxSeat.scaleY = 0.3;
	rightBoxSeat.rotation = -0.1;
	backgroundElements.push(rightBoxSeat);
	// Premium seats inside right box removed
	// Synchronized flickering for wall candelabras
	tween(wallCandelabra, {
		rotation: 0.03,
		alpha: 0.9
	}, {
		duration: 1500 + Math.random() * 700,
		easing: tween.easeInOut,
		onFinish: function onFinish() {
			tween(wallCandelabra, {
				rotation: -0.03,
				alpha: 1.0
			}, {
				duration: 1500 + Math.random() * 700,
				easing: tween.easeInOut,
				onFinish: arguments.callee
			});
		}
	});
	tween(rightWallCandelabra, {
		rotation: -0.03,
		alpha: 0.9
	}, {
		duration: 1500 + Math.random() * 700,
		easing: tween.easeInOut,
		onFinish: function onFinish() {
			tween(rightWallCandelabra, {
				rotation: 0.03,
				alpha: 1.0
			}, {
				duration: 1500 + Math.random() * 700,
				easing: tween.easeInOut,
				onFinish: arguments.callee
			});
		}
	});
}
// === ENTRANCE AREA ===
// Grand entrance architecture
var entranceArch = game.addChild(LK.getAsset('archDetail', {
	anchorX: 0.5,
	anchorY: 1
}));
entranceArch.x = 1750;
entranceArch.y = 2732;
entranceArch.scaleX = 2.5;
entranceArch.scaleY = 1.8;
backgroundElements.push(entranceArch);
// Entrance pillars
var leftEntrancePillar = game.addChild(LK.getAsset('pillar', {
	anchorX: 0.5,
	anchorY: 1
}));
leftEntrancePillar.x = 1600;
leftEntrancePillar.y = 2732;
leftEntrancePillar.scaleX = 0.7;
leftEntrancePillar.scaleY = 1.0;
backgroundElements.push(leftEntrancePillar);
var rightEntrancePillar = game.addChild(LK.getAsset('pillar', {
	anchorX: 0.5,
	anchorY: 1
}));
rightEntrancePillar.x = 1900;
rightEntrancePillar.y = 2732;
rightEntrancePillar.scaleX = 0.7;
rightEntrancePillar.scaleY = 1.0;
backgroundElements.push(rightEntrancePillar);
// Entrance lighting
for (var i = 0; i < 3; i++) {
	var entranceCandelabra = game.addChild(LK.getAsset('candelabra', {
		anchorX: 0.5,
		anchorY: 1
	}));
	entranceCandelabra.x = 1600 + i * 150;
	entranceCandelabra.y = 2550;
	entranceCandelabra.scaleX = 1.0;
	entranceCandelabra.scaleY = 1.3;
	backgroundElements.push(entranceCandelabra);
	// Flickering effect for entrance lighting
	tween(entranceCandelabra, {
		scaleY: 1.35,
		alpha: 0.95
	}, {
		duration: 1200 + Math.random() * 600,
		easing: tween.easeInOut,
		onFinish: function onFinish() {
			tween(entranceCandelabra, {
				scaleY: 1.3,
				alpha: 1.0
			}, {
				duration: 1200 + Math.random() * 600,
				easing: tween.easeInOut,
				onFinish: arguments.callee
			});
		}
	});
}
// === CURTAINS AND DRAPING ===
// Side curtains for proper hall framing
var leftCurtain = game.addChild(LK.getAsset('curtain', {
	anchorX: 0,
	anchorY: 0
}));
leftCurtain.x = 0;
leftCurtain.y = 0;
leftCurtain.scaleX = 0.5;
leftCurtain.scaleY = 1.2;
backgroundElements.push(leftCurtain);
var rightCurtain = game.addChild(LK.getAsset('curtain', {
	anchorX: 1,
	anchorY: 0
}));
rightCurtain.x = 2048;
rightCurtain.y = 0;
rightCurtain.scaleX = 0.5;
rightCurtain.scaleY = 1.2;
backgroundElements.push(rightCurtain);
// === CONDUCTOR ANIMATION ===
// Conductor movement for liveliness
tween(conductor, {
	rotation: 0.06
}, {
	duration: 1800,
	easing: tween.easeInOut,
	onFinish: function onFinish() {
		tween(conductor, {
			rotation: -0.06
		}, {
			duration: 1800,
			easing: tween.easeInOut,
			onFinish: arguments.callee
		});
	}
});
// Function to create floating musical notes
function playMelodia() {
	// Only start music if not muted
	if (!musicMuted) {
		try {
			LK.stopMusic();
			console.log("Successfully stopped current music");
		} catch (error) {
			console.log("Error stopping music:", error);
		}
		gameplayMusicPlaying = false;
		try {
			LK.playMusic('Melodia', {
				loop: true
			});
			gameplayMusicPlaying = true;
			console.log("Successfully started Melodia");
		} catch (error) {
			console.log("Error starting Melodia:", error);
			gameplayMusicPlaying = false;
		}
	} else {
		console.log("Music not started - muted:", musicMuted);
	}
}
function startMelodia() {
	// Only start music if not muted
	if (!musicMuted) {
		try {
			LK.playMusic('Melodia', {
				loop: true
			});
			gameplayMusicPlaying = true;
			console.log("Successfully started Melodia");
		} catch (error) {
			console.log("Error starting Melodia:", error);
			gameplayMusicPlaying = false;
		}
	} else {
		console.log("Music not started - muted:", musicMuted);
	}
}
// Manual music control function - stops current music
function stopMusicSystem() {
	console.log("Stopping music system manually");
	try {
		LK.stopMusic();
	} catch (error) {
		console.log("Error stopping music:", error);
	}
	gameplayMusicPlaying = false;
	console.log("Music system stopped");
}
function createFloatingNote() {
	var note = game.addChild(LK.getAsset('musicNote', {
		anchorX: 0.5,
		anchorY: 0.5
	}));
	note.x = Math.random() * 2048;
	note.y = 2732 + 100;
	note.alpha = 0.6;
	floatingNotes.push(note);
	// Animate note floating upward
	tween(note, {
		y: -100,
		rotation: Math.PI * 2,
		alpha: 0
	}, {
		duration: 8000 + Math.random() * 4000,
		easing: tween.easeOut,
		onFinish: function onFinish() {
			if (note.parent) {
				note.destroy();
			}
			var index = floatingNotes.indexOf(note);
			if (index > -1) {
				floatingNotes.splice(index, 1);
			}
		}
	});
}
// Create initial floating notes
for (var i = 0; i < 5; i++) {
	LK.setTimeout(function () {
		createFloatingNote();
	}, Math.random() * 3000);
}
// === MAIN MENU ===
menuContainer = new Container();
// Add menu container after all background elements to ensure it appears on top
game.addChild(menuContainer);
var menuBackground = menuContainer.addChild(LK.getAsset('woodPanel', {
	anchorX: 0.5,
	anchorY: 0.5
}));
menuBackground.x = 1024;
menuBackground.y = 1366;
menuBackground.scaleX = 4.5;
menuBackground.scaleY = 6;
menuBackground.alpha = 0.95;
menuBackground.tint = 0x3D2914;
var startButton = menuContainer.addChild(LK.getAsset('BotonStart', {
	anchorX: 0.5,
	anchorY: 0.5
}));
startButton.x = 1024;
startButton.y = 1000;
startButton.scaleX = 1.5;
startButton.scaleY = 1.5;
var tutorialButton = menuContainer.addChild(LK.getAsset('TutorialB', {
	anchorX: 0.5,
	anchorY: 0.5
}));
tutorialButton.x = 1024;
tutorialButton.y = 1300;
tutorialButton.scaleX = 1.5;
tutorialButton.scaleY = 1.5;
startButton.down = function () {
	// Show title intro with curtains
	showTitleIntro();
};
tutorialButton.down = function () {
	gameState = 'tutorial';
	tutorialStep = 0;
	menuContainer.visible = false;
	showTutorial();
};
// === TUTORIAL SYSTEM ===
tutorialContainer = new Container();
tutorialContainer.visible = false;
// Add tutorial container after all background elements to ensure it appears on top
game.addChild(tutorialContainer);
var tutorialBackground = tutorialContainer.addChild(LK.getAsset('woodPanel', {
	anchorX: 0.5,
	anchorY: 0.5
}));
tutorialBackground.x = 1024;
tutorialBackground.y = 1366;
tutorialBackground.scaleX = 4.5;
tutorialBackground.scaleY = 5.5;
tutorialBackground.alpha = 0.95;
tutorialBackground.tint = 0x8B4513;
var tutorialTitleText = tutorialContainer.addChild(new Text2('♪ TUTORIAL ♪', {
	size: 100,
	fill: 0xFFD700,
	font: "'Blackletter', 'Old English Text MT', 'Germania One', serif"
}));
tutorialTitleText.anchor.set(0.5, 0.5);
tutorialTitleText.x = 1024;
tutorialTitleText.y = 300;
var tutorialStepText = tutorialContainer.addChild(new Text2('', {
	size: 60,
	fill: 0xF5F5DC,
	font: "'Blackletter', 'Old English Text MT', 'Germania One', serif"
}));
tutorialStepText.anchor.set(0.5, 0.5);
tutorialStepText.x = 1024;
tutorialStepText.y = 1000;
var nextButton = tutorialContainer.addChild(LK.getAsset('guitarTower', {
	anchorX: 0.5,
	anchorY: 0.5
}));
nextButton.x = 1200;
nextButton.y = 1600;
var nextButtonText = tutorialContainer.addChild(new Text2('♫ NEXT ♫', {
	size: 60,
	fill: 0xFFD700,
	font: "'Blackletter', 'Old English Text MT', 'Germania One', serif"
}));
nextButtonText.anchor.set(0.5, 0.5);
nextButtonText.x = 1200;
nextButtonText.y = 1680;
var backButton = tutorialContainer.addChild(LK.getAsset('drumTower', {
	anchorX: 0.5,
	anchorY: 0.5
}));
backButton.x = 848;
backButton.y = 1600;
var backButtonText = tutorialContainer.addChild(new Text2('♪ BACK TO MENU ♪', {
	size: 60,
	fill: 0xFFD700,
	font: "'Blackletter', 'Old English Text MT', 'Germania One', serif"
}));
backButtonText.anchor.set(0.5, 0.5);
backButtonText.x = 848;
backButtonText.y = 1680;
var tutorialSteps = ['Welcome to Concert Hall Defense!\nProtect the stage from invading enemies.', 'Enemies follow the wooden path from bottom to top.\nThey want to disrupt the concert!', 'Click on build spots (circular areas) to place towers.\nEach tower has different abilities and costs.', 'DRUM TOWERS ($50): Fast firing with area damage.\nGreat for groups of enemies.', 'TRUMPET TOWERS ($80): Push enemies back down the path.\nUse to buy more time.', 'GUITAR TOWERS ($120): Chain lightning between enemies.\nEffective against clustered foes.', 'VIOLIN TOWERS ($100): Slow enemies with magical music.\nPerfect for crowd control.', 'DJ TOWERS ($200): Massive area damage with blinding effects.\nExpensive but very powerful.', 'Place towers strategically around the path.\nElevated positions like balconies give better coverage.', 'You earn gold by defeating enemies.\nUse it wisely to build your defense!', 'Good luck defending the concert hall!\nThe show must go on!'];
function showTutorial() {
	tutorialContainer.visible = true;
	// Move tutorial container to front to ensure visibility
	game.removeChild(tutorialContainer);
	game.addChild(tutorialContainer);
	updateTutorialStep();
}
function updateTutorialStep() {
	if (tutorialStep < tutorialSteps.length) {
		tutorialStepText.setText(tutorialSteps[tutorialStep]);
		nextButtonText.setText(tutorialStep === tutorialSteps.length - 1 ? 'START GAME' : 'NEXT');
	} else {
		gameState = 'playing';
		tutorialContainer.visible = false;
		startNextWave();
	}
}
nextButton.down = function () {
	tutorialStep++;
	if (tutorialStep >= tutorialSteps.length) {
		gameState = 'playing';
		tutorialContainer.visible = false;
		startNextWave();
	} else {
		updateTutorialStep();
	}
};
backButton.down = function () {
	gameState = 'menu';
	tutorialContainer.visible = false;
	menuContainer.visible = true;
};
// Path definition - reversed to go from bottom to top
var pathPoints = [{
	x: 1750,
	y: 2250
}, {
	x: 1700,
	y: 2100
}, {
	x: 1650,
	y: 1950
}, {
	x: 1550,
	y: 1800
}, {
	x: 1400,
	y: 1750
}, {
	x: 1250,
	y: 1700
}, {
	x: 1100,
	y: 1650
}, {
	x: 950,
	y: 1600
}, {
	x: 800,
	y: 1550
}, {
	x: 650,
	y: 1500
}, {
	x: 500,
	y: 1450
}, {
	x: 350,
	y: 1400
}, {
	x: 200,
	y: 1300
}, {
	x: 100,
	y: 1150
}, {
	x: 200,
	y: 1000
}, {
	x: 350,
	y: 950
}, {
	x: 500,
	y: 900
}, {
	x: 650,
	y: 800
}, {
	x: 700,
	y: 650
}, {
	x: 650,
	y: 500
}, {
	x: 500,
	y: 400
}, {
	x: 350,
	y: 300
}, {
	x: 200,
	y: 300
}, {
	x: 50,
	y: 300
}];
// Create elegant wooden walkway with proper connectivity
for (var i = 0; i < pathPoints.length; i++) {
	var pathNode = game.addChild(LK.getAsset('woodPanel', {
		anchorX: 0.5,
		anchorY: 0.5
	}));
	pathNode.x = pathPoints[i].x;
	pathNode.y = pathPoints[i].y;
	pathNode.scaleX = 0.4;
	pathNode.scaleY = 0.4;
	pathNode.alpha = 0.95;
	pathNode.tint = 0xD2691E; // Warm wood color
	// Calculate rotation based on path direction for better connectivity
	if (i < pathPoints.length - 1) {
		var dx = pathPoints[i + 1].x - pathPoints[i].x;
		var dy = pathPoints[i + 1].y - pathPoints[i].y;
		pathNode.rotation = Math.atan2(dy, dx);
	} else if (i > 0) {
		var dx = pathPoints[i].x - pathPoints[i - 1].x;
		var dy = pathPoints[i].y - pathPoints[i - 1].y;
		pathNode.rotation = Math.atan2(dy, dx);
	}
	// Add gentle animation to make the wooden path feel alive
	tween(pathNode, {
		scaleX: 0.42,
		alpha: 1.0
	}, {
		duration: 2000 + Math.random() * 1000,
		easing: tween.easeInOut,
		onFinish: function onFinish() {
			tween(pathNode, {
				scaleX: 0.4,
				alpha: 0.95
			}, {
				duration: 2000 + Math.random() * 1000,
				easing: tween.easeInOut,
				onFinish: arguments.callee
			});
		}
	});
	// Add connecting wooden planks between path points for better continuity
	if (i < pathPoints.length - 1) {
		var distance = Math.sqrt(Math.pow(pathPoints[i + 1].x - pathPoints[i].x, 2) + Math.pow(pathPoints[i + 1].y - pathPoints[i].y, 2));
		var numConnectors = Math.floor(distance / 80); // Add connectors every 80 pixels
		for (var j = 1; j <= numConnectors; j++) {
			var ratio = j / (numConnectors + 1);
			var connectorX = pathPoints[i].x + (pathPoints[i + 1].x - pathPoints[i].x) * ratio;
			var connectorY = pathPoints[i].y + (pathPoints[i + 1].y - pathPoints[i].y) * ratio;
			var connector = game.addChild(LK.getAsset('woodPanel', {
				anchorX: 0.5,
				anchorY: 0.5
			}));
			connector.x = connectorX;
			connector.y = connectorY;
			connector.scaleX = 0.3;
			connector.scaleY = 0.3;
			connector.alpha = 0.8;
			connector.tint = 0xCD853F; // Slightly different wood tone for variety
			var dx = pathPoints[i + 1].x - pathPoints[i].x;
			var dy = pathPoints[i + 1].y - pathPoints[i].y;
			connector.rotation = Math.atan2(dy, dx) + (Math.random() - 0.5) * 0.2;
		}
	}
}
// Create goal
var goal = game.addChild(LK.getAsset('goal', {
	anchorX: 0.5,
	anchorY: 0.5
}));
goal.x = pathPoints[pathPoints.length - 1].x;
goal.y = pathPoints[pathPoints.length - 1].y;
// === BUILD SPOTS CREATION ===
var purpleNumbers = []; // Keep empty array for build spot reference
// Create build spots positioned every 2 wooden path tables on both left and right sides
for (var i = 0; i < pathPoints.length - 1; i += 2) {
	// Get the path point for this segment
	var pathPoint = pathPoints[i];
	// Calculate direction to next path point for perpendicular positioning
	var nextPathPoint = pathPoints[Math.min(i + 1, pathPoints.length - 1)];
	var pathDx = nextPathPoint.x - pathPoint.x;
	var pathDy = nextPathPoint.y - pathPoint.y;
	var pathLength = Math.sqrt(pathDx * pathDx + pathDy * pathDy);
	if (pathLength > 0) {
		// Normalize the path direction
		pathDx /= pathLength;
		pathDy /= pathLength;
		// Calculate perpendicular vectors (90 degrees rotated)
		var perpDx = -pathDy; // Left side perpendicular
		var perpDy = pathDx;
		// Distance from path center to build spots
		var offsetDistance = 150;
		// Create left side build spot
		var leftBuildSpot = new BuildSpot(buildSpots.length + 1);
		leftBuildSpot.x = pathPoint.x + perpDx * offsetDistance;
		leftBuildSpot.y = pathPoint.y + perpDy * offsetDistance;
		buildSpots.push(leftBuildSpot);
		game.addChild(leftBuildSpot);
		// Create right side build spot
		var rightBuildSpot = new BuildSpot(buildSpots.length + 1);
		rightBuildSpot.x = pathPoint.x - perpDx * offsetDistance;
		rightBuildSpot.y = pathPoint.y - perpDy * offsetDistance;
		buildSpots.push(rightBuildSpot);
		game.addChild(rightBuildSpot);
	}
}
// UI Elements
// Gold background panel for better visibility
var goldBackground = LK.getAsset('fondo', {
	anchorX: 0.5,
	anchorY: 0.5
});
goldBackground.scaleX = 0.5;
goldBackground.scaleY = 0.25;
goldBackground.alpha = 0.9;
goldBackground.tint = 0x8B4513;
LK.gui.topRight.addChild(goldBackground);
goldBackground.x = -200;
goldBackground.y = 100;
// Gold icon and text
var goldIcon = LK.getAsset('gold', {
	anchorX: 0.5,
	anchorY: 0.5
});
goldIcon.tint = 0xFFD700;
goldIcon.scaleX = 0.8;
goldIcon.scaleY = 0.8;
LK.gui.topRight.addChild(goldIcon);
goldIcon.x = -280;
goldIcon.y = 100;
var goldText = new Text2(gold, {
	size: 80,
	fill: 0xFFD700,
	font: "'Blackletter', 'Old English Text MT', 'Germania One', serif"
});
goldText.anchor.set(0.5, 0.5);
LK.gui.topRight.addChild(goldText);
goldText.x = -200;
goldText.y = 100;
// Lives background panel for better visibility
var livesBackground = LK.getAsset('fondo', {
	anchorX: 0.5,
	anchorY: 0.5
});
livesBackground.scaleX = 0.5;
livesBackground.scaleY = 0.25;
livesBackground.alpha = 0.9;
livesBackground.tint = 0x8B4513;
LK.gui.topRight.addChild(livesBackground);
livesBackground.x = -200;
livesBackground.y = 300;
// Lives icon and text
var livesIcon = LK.getAsset('lives', {
	anchorX: 0.5,
	anchorY: 0.5
});
livesIcon.tint = 0xFF0000;
livesIcon.scaleX = 0.8;
livesIcon.scaleY = 0.8;
LK.gui.topRight.addChild(livesIcon);
livesIcon.x = -280;
livesIcon.y = 300;
var livesText = new Text2(lives, {
	size: 85,
	fill: 0xFF6B6B,
	font: "'Blackletter', 'Old English Text MT', 'Germania One', serif"
});
livesText.anchor.set(0.5, 0.5);
LK.gui.topRight.addChild(livesText);
livesText.x = -200;
livesText.y = 300;
var waveText = new Text2('♪ WAVE ' + wave + ' ♪', {
	size: 80,
	fill: 0xFFD700,
	font: "'Blackletter', 'Old English Text MT', 'Germania One', serif"
});
waveText.anchor.set(0.5, 0.5);
LK.gui.bottomLeft.addChild(waveText);
waveText.x = 320;
waveText.y = -150;
// Add wave background for better visibility
var waveBackground = LK.getAsset('fondo', {
	anchorX: 0.5,
	anchorY: 0.5
});
waveBackground.scaleX = 1.2;
waveBackground.scaleY = 0.4;
waveBackground.alpha = 0.7;
waveBackground.tint = 0x8B4513;
LK.gui.bottomLeft.addChild(waveBackground);
waveBackground.x = 320;
waveBackground.y = -150;
// Move wave text to front
LK.gui.bottomLeft.removeChild(waveText);
LK.gui.bottomLeft.addChild(waveText);
// Add music mute button
var musicMuted = false;
var muteButtonBackground = LK.getAsset('fondo', {
	anchorX: 0.5,
	anchorY: 0.5
});
muteButtonBackground.scaleX = 0.4;
muteButtonBackground.scaleY = 0.25;
muteButtonBackground.alpha = 0.9;
muteButtonBackground.tint = 0x8B4513;
LK.gui.topRight.addChild(muteButtonBackground);
muteButtonBackground.x = -200;
muteButtonBackground.y = 450;
var muteButton = LK.getAsset('violinTower', {
	anchorX: 0.5,
	anchorY: 0.5
});
muteButton.scaleX = 0.8;
muteButton.scaleY = 0.8;
LK.gui.topRight.addChild(muteButton);
muteButton.x = -200;
muteButton.y = 450;
var muteText = new Text2('♪ MUSIC ♪', {
	size: 45,
	fill: 0xFFD700,
	font: "'Blackletter', 'Old English Text MT', 'Germania One', serif"
});
muteText.anchor.set(0.5, 0.5);
LK.gui.topRight.addChild(muteText);
muteText.x = -200;
muteText.y = 500;
// Start Wave button
var startWaveBackground = LK.getAsset('fondo', {
	anchorX: 0.5,
	anchorY: 0.5
});
startWaveBackground.scaleX = 0.8;
startWaveBackground.scaleY = 0.4;
startWaveBackground.alpha = 0.9;
startWaveBackground.tint = 0x8B4513;
LK.gui.bottomRight.addChild(startWaveBackground);
startWaveBackground.x = -200;
startWaveBackground.y = -150;
var startWaveButton = LK.getAsset('trumpetTower', {
	anchorX: 0.5,
	anchorY: 0.5
});
startWaveButton.scaleX = 1.0;
startWaveButton.scaleY = 1.0;
LK.gui.bottomRight.addChild(startWaveButton);
startWaveButton.x = -200;
startWaveButton.y = -150;
var startWaveText = new Text2('♪ START WAVE ♪', {
	size: 50,
	fill: 0xFFD700,
	font: "'Blackletter', 'Old English Text MT', 'Germania One', serif"
});
startWaveText.anchor.set(0.5, 0.5);
LK.gui.bottomRight.addChild(startWaveText);
startWaveText.x = -200;
startWaveText.y = -100;
var autoStartText = new Text2('Auto: 5s', {
	size: 35,
	fill: 0xFFFFFF,
	font: "'Blackletter', 'Old English Text MT', 'Germania One', serif"
});
autoStartText.anchor.set(0.5, 0.5);
LK.gui.bottomRight.addChild(autoStartText);
autoStartText.x = -200;
autoStartText.y = -70;
// Grand Piano Power Button (initially hidden)
grandPianoButtonBackground = LK.getAsset('fondo', {
	anchorX: 0.5,
	anchorY: 0.5
});
grandPianoButtonBackground.scaleX = 0.8;
grandPianoButtonBackground.scaleY = 0.5;
grandPianoButtonBackground.alpha = 0.9;
grandPianoButtonBackground.tint = 0x8B4513;
LK.gui.bottomLeft.addChild(grandPianoButtonBackground);
grandPianoButtonBackground.x = 200;
grandPianoButtonBackground.y = -400;
grandPianoButtonBackground.visible = false;
grandPianoPowerButton = LK.getAsset('grandPiano', {
	anchorX: 0.5,
	anchorY: 0.5
});
grandPianoPowerButton.scaleX = 1.0;
grandPianoPowerButton.scaleY = 1.0;
LK.gui.bottomLeft.addChild(grandPianoPowerButton);
grandPianoPowerButton.x = 200;
grandPianoPowerButton.y = -400;
grandPianoPowerButton.visible = false;
grandPianoPowerText = new Text2('♪ GRAND PIANO ♪', {
	size: 45,
	fill: 0xFFD700,
	font: "'Blackletter', 'Old English Text MT', 'Germania One', serif"
});
grandPianoPowerText.anchor.set(0.5, 0.5);
LK.gui.bottomLeft.addChild(grandPianoPowerText);
grandPianoPowerText.x = 200;
grandPianoPowerText.y = -350;
grandPianoPowerText.visible = false;
grandPianoCooldownText = new Text2('Ready!', {
	size: 35,
	fill: 0x00FF00,
	font: "'Blackletter', 'Old English Text MT', 'Germania One', serif"
});
grandPianoCooldownText.anchor.set(0.5, 0.5);
LK.gui.bottomLeft.addChild(grandPianoCooldownText);
grandPianoCooldownText.x = 200;
grandPianoCooldownText.y = -320;
grandPianoCooldownText.visible = false;
muteButton.down = function () {
	if (musicMuted) {
		// Unmuting - start appropriate music
		if (gameState === 'playing') {
			console.log("Unmuting - starting Melodia");
			playMelodia();
		} else {
			// In menu, play menu music
			console.log("Unmuting - starting menu music");
			try {
				LK.playMusic('MusicaInicio', {
					loop: true
				});
			} catch (error) {
				console.log("Error starting menu music:", error);
			}
		}
		muteText.setText('♪ MUSIC ♪');
		muteButton.tint = 0xFFFFFF;
		musicMuted = false;
	} else {
		// Muting - stop all music and reset system
		console.log("Muting music");
		stopMusicSystem();
		muteText.setText('♪ MUTED ♪');
		muteButton.tint = 0x888888;
		musicMuted = true;
	}
};
startWaveButton.down = function () {
	if (gameState === 'playing' && wavePaused && enemies.length === 0) {
		startCurrentWave();
	}
};
grandPianoPowerButton.down = function () {
	if (grandPianoPowerUnlocked && grandPianoCooldownRemaining === 0 && !grandPianoPowerActive && gameState === 'playing') {
		enterGrandPianoTargetingMode();
	}
};
// Build menu elements (initially hidden)
var buildMenuContainer = new Container();
game.addChild(buildMenuContainer);
buildMenuContainer.visible = false;
var drumButton = buildMenuContainer.addChild(LK.getAsset('drumTower', {
	anchorX: 0.5,
	anchorY: 0.5
}));
var guitarButton = buildMenuContainer.addChild(LK.getAsset('guitarTower', {
	anchorX: 0.5,
	anchorY: 0.5
}));
var violinButton = buildMenuContainer.addChild(LK.getAsset('violinTower', {
	anchorX: 0.5,
	anchorY: 0.5
}));
var trumpetButton = buildMenuContainer.addChild(LK.getAsset('trumpetTower', {
	anchorX: 0.5,
	anchorY: 0.5
}));
var djButton = buildMenuContainer.addChild(LK.getAsset('djTower', {
	anchorX: 0.5,
	anchorY: 0.5
}));
var drumText = buildMenuContainer.addChild(new Text2('$50', {
	size: 45,
	fill: 0xFFD700,
	font: "'Blackletter', 'Old English Text MT', 'Germania One', serif"
}));
drumText.anchor.set(0.5, 0);
var trumpetText = buildMenuContainer.addChild(new Text2('$80', {
	size: 45,
	fill: 0xFFD700,
	font: "'Blackletter', 'Old English Text MT', 'Germania One', serif"
}));
trumpetText.anchor.set(0.5, 0);
var guitarText = buildMenuContainer.addChild(new Text2('$120', {
	size: 45,
	fill: 0xFFD700,
	font: "'Blackletter', 'Old English Text MT', 'Germania One', serif"
}));
guitarText.anchor.set(0.5, 0);
var violinText = buildMenuContainer.addChild(new Text2('$100', {
	size: 45,
	fill: 0xFFD700,
	font: "'Blackletter', 'Old English Text MT', 'Germania One', serif"
}));
violinText.anchor.set(0.5, 0);
var djText = buildMenuContainer.addChild(new Text2('$200', {
	size: 45,
	fill: 0xFFD700,
	font: "'Blackletter', 'Old English Text MT', 'Germania One', serif"
}));
djText.anchor.set(0.5, 0);
// Upgrade menu elements (initially hidden)
upgradeMenuContainer = new Container();
game.addChild(upgradeMenuContainer);
upgradeMenuContainer.visible = false;
var upgradeMenuBackground = upgradeMenuContainer.addChild(LK.getAsset('woodPanel', {
	anchorX: 0.5,
	anchorY: 0.5
}));
upgradeMenuBackground.scaleX = 1.2;
upgradeMenuBackground.scaleY = 0.8;
upgradeMenuBackground.alpha = 0.95;
upgradeMenuBackground.tint = 0x8B4513;
var upgradeButton = upgradeMenuContainer.addChild(LK.getAsset('upgradeIcon', {
	anchorX: 0.5,
	anchorY: 0.5
}));
upgradeButton.x = -80;
upgradeButton.y = 0;
upgradeButton.scaleX = 1.0;
upgradeButton.scaleY = 1.0;
var removeButton = upgradeMenuContainer.addChild(LK.getAsset('removeIcon', {
	anchorX: 0.5,
	anchorY: 0.5
}));
removeButton.x = 80;
removeButton.y = 0;
removeButton.scaleX = 1.0;
removeButton.scaleY = 1.0;
var upgradeCostText = upgradeMenuContainer.addChild(new Text2('UPGRADE\n$50', {
	size: 40,
	fill: 0xFFFFFF,
	font: "'Blackletter', 'Old English Text MT', 'Germania One', serif"
}));
upgradeCostText.anchor.set(0.5, 0);
upgradeCostText.x = -80;
upgradeCostText.y = 50;
var removeText = upgradeMenuContainer.addChild(new Text2('REMOVE\nRefund 50%', {
	size: 40,
	fill: 0xFFFFFF,
	font: "'Blackletter', 'Old English Text MT', 'Germania One', serif"
}));
removeText.anchor.set(0.5, 0);
removeText.x = 120;
removeText.y = 50;
var towerInfoText = upgradeMenuContainer.addChild(new Text2('Level 1 Tower', {
	size: 45,
	fill: 0xFFFFFF,
	font: "'Blackletter', 'Old English Text MT', 'Germania One', serif"
}));
towerInfoText.anchor.set(0.5, 1);
towerInfoText.x = 0;
towerInfoText.y = -50;
function updateUI() {
	goldText.setText(gold);
	livesText.setText(lives);
	waveText.setText('♪ WAVE ' + wave + ' ♪');
	updateGrandPianoPowerUI();
}
function showBuildMenu(buildSpot) {
	showingBuildMenu = true;
	selectedBuildSpot = buildSpot;
	buildMenuContainer.visible = true;
	// Ensure build menu appears above all other elements
	game.removeChild(buildMenuContainer);
	game.addChild(buildMenuContainer);
	// Position menu near build spot
	buildMenuContainer.x = buildSpot.x;
	buildMenuContainer.y = buildSpot.y - 200;
	// Create circular menu layout
	var radius = 120;
	var centerX = 0;
	var centerY = 0;
	// Position buttons in a circle
	var angleStep = Math.PI * 2 / 5; // 5 buttons in circle
	drumButton.x = centerX + Math.cos(0) * radius;
	drumButton.y = centerY + Math.sin(0) * radius;
	trumpetButton.x = centerX + Math.cos(angleStep) * radius;
	trumpetButton.y = centerY + Math.sin(angleStep) * radius;
	guitarButton.x = centerX + Math.cos(angleStep * 2) * radius;
	guitarButton.y = centerY + Math.sin(angleStep * 2) * radius;
	violinButton.x = centerX + Math.cos(angleStep * 3) * radius;
	violinButton.y = centerY + Math.sin(angleStep * 3) * radius;
	djButton.x = centerX + Math.cos(angleStep * 4) * radius;
	djButton.y = centerY + Math.sin(angleStep * 4) * radius;
	// Position text closer to buttons in circle
	var textRadius = radius + 30;
	drumText.x = centerX + Math.cos(0) * textRadius;
	drumText.y = centerY + Math.sin(0) * textRadius;
	trumpetText.x = centerX + Math.cos(angleStep) * textRadius;
	trumpetText.y = centerY + Math.sin(angleStep) * textRadius;
	guitarText.x = centerX + Math.cos(angleStep * 2) * textRadius;
	guitarText.y = centerY + Math.sin(angleStep * 2) * textRadius;
	violinText.x = centerX + Math.cos(angleStep * 3) * textRadius;
	violinText.y = centerY + Math.sin(angleStep * 3) * textRadius;
	djText.x = centerX + Math.cos(angleStep * 4) * textRadius;
	djText.y = centerY + Math.sin(angleStep * 4) * textRadius;
	// Start buttons small and animate them opening
	drumButton.scaleX = 0.1;
	drumButton.scaleY = 0.1;
	trumpetButton.scaleX = 0.1;
	trumpetButton.scaleY = 0.1;
	guitarButton.scaleX = 0.1;
	guitarButton.scaleY = 0.1;
	violinButton.scaleX = 0.1;
	violinButton.scaleY = 0.1;
	djButton.scaleX = 0.1;
	djButton.scaleY = 0.1;
	// Animate buttons appearing in sequence with slight delays
	tween(drumButton, {
		scaleX: 1.2,
		scaleY: 1.2
	}, {
		duration: 300,
		easing: tween.easeOut
	});
	LK.setTimeout(function () {
		tween(trumpetButton, {
			scaleX: 1.2,
			scaleY: 1.2
		}, {
			duration: 300,
			easing: tween.easeOut
		});
	}, 100);
	LK.setTimeout(function () {
		tween(guitarButton, {
			scaleX: 1.2,
			scaleY: 1.2
		}, {
			duration: 300,
			easing: tween.easeOut
		});
	}, 200);
	LK.setTimeout(function () {
		tween(violinButton, {
			scaleX: 1.2,
			scaleY: 1.2
		}, {
			duration: 300,
			easing: tween.easeOut
		});
	}, 300);
	LK.setTimeout(function () {
		tween(djButton, {
			scaleX: 1.2,
			scaleY: 1.2
		}, {
			duration: 300,
			easing: tween.easeOut
		});
	}, 400);
}
function hideBuildMenu() {
	showingBuildMenu = false;
	selectedBuildSpot = null;
	buildMenuContainer.visible = false;
}
function showUpgradeMenu(tower) {
	if (showingBuildMenu) return; // Don't show if build menu is open
	// Force hide any existing upgrade menu first
	if (showingUpgradeMenu) {
		hideUpgradeMenu();
		// Wait for hide animation to complete before showing new menu
		LK.setTimeout(function () {
			actuallyShowUpgradeMenu(tower);
		}, 250);
		return;
	}
	actuallyShowUpgradeMenu(tower);
}
function actuallyShowUpgradeMenu(tower) {
	showingUpgradeMenu = true;
	selectedTower = tower;
	// Ensure container is properly reset
	upgradeMenuContainer.visible = true;
	upgradeMenuContainer.scaleX = 0.1;
	upgradeMenuContainer.scaleY = 0.1;
	upgradeMenuContainer.alpha = 0;
	// Position menu near tower but higher up
	upgradeMenuContainer.x = tower.x;
	upgradeMenuContainer.y = tower.y - 250;
	// Hide background for circular menu
	upgradeMenuBackground.visible = false;
	// Position buttons in circular layout
	var radius = 80;
	upgradeButton.x = -radius;
	upgradeButton.y = 0;
	removeButton.x = radius;
	removeButton.y = 0;
	// Update menu content based on tower level and type
	var upgradeCost = 0;
	if (tower.towerType === 'drum') {
		upgradeCost = tower.level === 1 ? 90 : tower.level === 2 ? 160 : 0;
	} else if (tower.towerType === 'trumpet') {
		upgradeCost = tower.level === 1 ? 130 : tower.level === 2 ? 200 : 0;
	} else if (tower.towerType === 'guitar') {
		upgradeCost = tower.level === 1 ? 180 : tower.level === 2 ? 250 : 0;
	} else if (tower.towerType === 'violin') {
		upgradeCost = tower.level === 1 ? 160 : tower.level === 2 ? 220 : 0;
	} else if (tower.towerType === 'dj') {
		upgradeCost = tower.level === 1 ? 280 : tower.level === 2 ? 350 : 0;
	}
	var canUpgrade = tower.level < 3 && gold >= upgradeCost;
	var refundAmount = Math.floor(tower.totalCost * 0.5);
	if (tower.level >= 3) {
		upgradeCostText.setText('UPGRADE\nMAX LEVEL');
		upgradeCostText.tint = 0x888888;
		upgradeButton.tint = 0x666666;
	} else {
		upgradeCostText.setText('UPGRADE\n$' + upgradeCost);
		upgradeCostText.tint = canUpgrade ? 0x00FF00 : 0xFF4444;
		upgradeButton.tint = canUpgrade ? 0xFFFFFF : 0x888888;
	}
	removeText.setText('REMOVE\nRefund $' + refundAmount);
	towerInfoText.setText('Level ' + tower.level + ' ' + tower.towerType.toUpperCase());
	// Position text relative to circular buttons - center upgrade cost below upgrade button
	upgradeCostText.x = -radius; // Center below upgrade button
	upgradeCostText.y = 50;
	removeText.x = radius;
	removeText.y = 50;
	towerInfoText.x = 0;
	towerInfoText.y = -50;
	// Animate menu opening
	tween(upgradeMenuContainer, {
		scaleX: 1.0,
		scaleY: 1.0,
		alpha: 1.0
	}, {
		duration: 300,
		easing: tween.easeOut
	});
}
function hideUpgradeMenu() {
	showingUpgradeMenu = false;
	selectedTower = null;
	tween(upgradeMenuContainer, {
		scaleX: 0.1,
		scaleY: 0.1,
		alpha: 0
	}, {
		duration: 200,
		easing: tween.easeIn,
		onFinish: function onFinish() {
			upgradeMenuContainer.visible = false;
		}
	});
}
function removeTower(tower) {
	if (!tower) return;
	// Calculate refund (50% of total investment)
	var refundAmount = Math.floor(tower.totalCost * 0.5);
	gold += refundAmount;
	// Find and free the build spot
	for (var i = 0; i < buildSpots.length; i++) {
		var spot = buildSpots[i];
		var distance = Math.sqrt((spot.x - tower.x) * (spot.x - tower.x) + (spot.y - tower.y) * (spot.y - tower.y));
		if (distance < 50) {
			// Close enough to be the same spot
			spot.occupied = false;
			break;
		}
	}
	// Remove from towers array
	var towerIndex = towers.indexOf(tower);
	if (towerIndex > -1) {
		towers.splice(towerIndex, 1);
	}
	// Destruction animation and sound
	LK.getSound('Destruir').play(); // Tower destruction sound
	tween(tower, {
		scaleX: 0.1,
		scaleY: 0.1,
		rotation: Math.PI * 2,
		alpha: 0
	}, {
		duration: 500,
		easing: tween.easeIn,
		onFinish: function onFinish() {
			tower.destroy();
		}
	});
	updateUI();
	hideUpgradeMenu();
}
function buildTower(towerType, cost) {
	console.log("buildTower called:", towerType, "cost:", cost, "gold:", gold, "selectedBuildSpot:", selectedBuildSpot);
	if (!selectedBuildSpot) {
		console.log("No build spot selected");
		return;
	}
	if (gold < cost) {
		console.log("Not enough gold:", gold, "needed:", cost);
		return;
	}
	console.log("Building tower...");
	// Deduct gold first
	gold -= cost;
	console.log("Gold after purchase:", gold);
	var tower = new Tower(towerType);
	tower.x = selectedBuildSpot.x;
	tower.y = selectedBuildSpot.y;
	towers.push(tower);
	game.addChild(tower);
	selectedBuildSpot.occupied = true;
	console.log("Tower built successfully at:", tower.x, tower.y);
	updateUI();
	hideBuildMenu();
	// Play specific sound for trumpet and guitar towers
	if (towerType === 'trumpet') {
		LK.getSound('sonidotrompeta').play();
	} else if (towerType === 'guitar') {
		LK.getSound('SonidoGuitarra').play();
	} else if (towerType === 'violin') {
		LK.getSound('SonidoV').play();
	} else if (towerType === 'dj') {
		LK.getSound('SonidoDJ').play();
	} else {
		LK.getSound('build').play();
	}
}
// Button handlers with proper event handling
drumButton.down = function (x, y, obj) {
	console.log("Drum button clicked, gold:", gold);
	if (gold >= 50) {
		buildTower('drum', 50);
	} else {
		console.log("Not enough gold for drum tower");
		LK.getSound('eror').play();
	}
};
guitarButton.down = function (x, y, obj) {
	console.log("Guitar button clicked, gold:", gold);
	if (gold >= 120) {
		buildTower('guitar', 120);
	} else {
		console.log("Not enough gold for guitar tower");
		LK.getSound('eror').play();
	}
};
violinButton.down = function (x, y, obj) {
	console.log("Violin button clicked, gold:", gold);
	if (gold >= 100) {
		buildTower('violin', 100);
	} else {
		console.log("Not enough gold for violin tower");
		LK.getSound('eror').play();
	}
};
trumpetButton.down = function (x, y, obj) {
	console.log("Trumpet button clicked, gold:", gold);
	if (gold >= 80) {
		buildTower('trumpet', 80);
	} else {
		console.log("Not enough gold for trumpet tower");
		LK.getSound('eror').play();
	}
};
djButton.down = function (x, y, obj) {
	console.log("DJ button clicked, gold:", gold);
	if (gold >= 200) {
		buildTower('dj', 200);
	} else {
		console.log("Not enough gold for DJ tower");
		LK.getSound('eror').play();
	}
};
// Upgrade menu button handlers
upgradeButton.down = function (x, y, obj) {
	if (selectedTower && selectedTower.level < 3) {
		var upgradeCost = 0;
		if (selectedTower.towerType === 'drum') {
			upgradeCost = selectedTower.level === 1 ? 90 : 160;
		} else if (selectedTower.towerType === 'trumpet') {
			upgradeCost = selectedTower.level === 1 ? 130 : 200;
		} else if (selectedTower.towerType === 'guitar') {
			upgradeCost = selectedTower.level === 1 ? 180 : 250;
		} else if (selectedTower.towerType === 'violin') {
			upgradeCost = selectedTower.level === 1 ? 160 : 220;
		} else if (selectedTower.towerType === 'dj') {
			upgradeCost = selectedTower.level === 1 ? 280 : 350;
		}
		if (gold >= upgradeCost) {
			if (selectedTower.upgrade()) {
				LK.getSound('build').play(); // Upgrade sound
				hideUpgradeMenu();
			}
		}
	}
};
removeButton.down = function (x, y, obj) {
	if (selectedTower) {
		removeTower(selectedTower);
	}
};
// Game click handler to hide menus - only if not clicking on buttons or build spots
game.move = function (x, y, obj) {
	if (grandPianoGhostMode && grandPianoGhost && grandPianoTargetArea) {
		grandPianoGhost.x = x;
		grandPianoGhost.y = y;
		grandPianoTargetArea.x = x;
		grandPianoTargetArea.y = y;
	}
};
game.down = function (x, y, obj) {
	// Handle Grand Piano targeting mode first
	if (grandPianoGhostMode) {
		activateGrandPianoPowerAt(x, y);
		return;
	}
	// Priority: Build menu takes precedence
	if (showingBuildMenu) {
		// Check if clicked within circular menu area
		var relativeX = x - buildMenuContainer.x;
		var relativeY = y - buildMenuContainer.y;
		var distanceFromCenter = Math.sqrt(relativeX * relativeX + relativeY * relativeY);
		var clickedOnButton = distanceFromCenter <= 180; // Circular area radius + buffer
		if (!clickedOnButton) {
			hideBuildMenu();
		}
		return; // Prevent other interactions when build menu is open
	}
	// Check if we clicked on a tower first - if so, don't hide upgrade menu
	var clickedOnTower = false;
	for (var i = 0; i < towers.length; i++) {
		var tower = towers[i];
		var dx = x - tower.x;
		var dy = y - tower.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		if (distance <= 60) {
			// Tower click radius
			clickedOnTower = true;
			break;
		}
	}
	// Handle upgrade menu interactions
	if (showingUpgradeMenu) {
		// Don't hide if we clicked on a tower (allowing tower switching)
		if (clickedOnTower) {
			return;
		}
		// Check if clicked within upgrade menu area
		var relativeX = x - upgradeMenuContainer.x;
		var relativeY = y - upgradeMenuContainer.y;
		var distanceFromCenter = Math.sqrt(relativeX * relativeX + relativeY * relativeY);
		var clickedOnButton = distanceFromCenter <= 150; // Menu area radius + buffer
		if (!clickedOnButton) {
			hideUpgradeMenu();
		}
		return; // Prevent other interactions when upgrade menu is open
	}
};
function calculateEnemiesForWave(waveNumber) {
	// Formula: enemiesTotal = round(10 × (1.15 ^ (waveActual - 1)))
	var baseCount = Math.round(10 * Math.pow(1.15, waveNumber - 1));
	// Modify for special waves
	if (currentSpecialWave === 'massive') {
		baseCount = Math.round(baseCount * 1.8); // 80% more enemies
	} else if (currentSpecialWave === 'runners') {
		baseCount = Math.round(baseCount * 1.3); // 30% more fast enemies
	}
	return baseCount;
}
function getSpawnIntervalForWave(waveNumber) {
	// Formula: max(0.5, 1.5 - (wave × 0.03)) in seconds, converted to ticks
	var intervalInSeconds = Math.max(0.5, 1.5 - waveNumber * 0.03);
	var intervalInTicks = Math.round(intervalInSeconds * 60); // Convert to 60fps ticks
	return intervalInTicks;
}
function getEnemyTypesForWave(waveNumber) {
	var availableTypes = [];
	// Check for special themed waves from wave 8+
	if (waveNumber >= 8) {
		var isSpecialWave = Math.random() < 0.25; // 25% chance
		if (isSpecialWave) {
			var specialWaves = ['runners', 'armored', 'massive'];
			var specialWave = specialWaves[Math.floor(Math.random() * specialWaves.length)];
			// Store special wave type for spawn modifications
			currentSpecialWave = specialWave;
			if (specialWave === 'runners') {
				return ['glitchAudio']; // Fast, low HP enemies
			} else if (specialWave === 'armored') {
				return ['ruidoBlanco']; // Slow, high HP enemies
			} else if (specialWave === 'massive') {
				// More enemies but weaker
				return ['notaDesafinada'];
			}
		}
	}
	currentSpecialWave = null; // Normal wave
	// Wave 1-4: Only Nota Desafinada
	if (waveNumber <= 4) {
		availableTypes = ['notaDesafinada'];
	}
	// Wave 5-9: Add Glitch de Audio
	else if (waveNumber >= 5 && waveNumber <= 9) {
		availableTypes = ['notaDesafinada', 'glitchAudio'];
	}
	// Wave 10-14: Add Ruido Blanco
	else if (waveNumber >= 10 && waveNumber <= 14) {
		availableTypes = ['notaDesafinada', 'glitchAudio', 'ruidoBlanco'];
	}
	// Wave 15-19: Add Eco Oscuro
	else if (waveNumber >= 15 && waveNumber <= 19) {
		availableTypes = ['notaDesafinada', 'glitchAudio', 'ruidoBlanco', 'ecoOscuro'];
	}
	// Wave 20-24: Add Autotune Malicioso
	else if (waveNumber >= 20 && waveNumber <= 24) {
		availableTypes = ['notaDesafinada', 'glitchAudio', 'ruidoBlanco', 'ecoOscuro', 'autotuneMalicioso'];
	}
	// Wave 25+: All enemy types with elites
	else {
		availableTypes = ['notaDesafinada', 'glitchAudio', 'ruidoBlanco', 'ecoOscuro', 'autotuneMalicioso'];
	}
	return availableTypes;
}
function getEnemyTypeWeights(waveNumber, availableTypes) {
	var weights = {};
	// Calculate probability of strong enemy: min(0.6, 0.05 × wave)
	var strongEnemyProbability = Math.min(0.6, 0.05 * waveNumber);
	var weakEnemyProbability = 1 - strongEnemyProbability;
	// Early waves (1-4): Only Nota Desafinada
	if (waveNumber <= 4) {
		weights['notaDesafinada'] = 100;
	}
	// Waves 5-9: Nota Desafinada + Glitch Audio
	else if (waveNumber >= 5 && waveNumber <= 9) {
		weights['notaDesafinada'] = Math.round(weakEnemyProbability * 100);
		weights['glitchAudio'] = Math.round(strongEnemyProbability * 100);
	}
	// Waves 10-14: Add Ruido Blanco
	else if (waveNumber >= 10 && waveNumber <= 14) {
		var basicProportion = Math.round(weakEnemyProbability * 50);
		var strongProportion = Math.round(strongEnemyProbability * 50);
		weights['notaDesafinada'] = basicProportion;
		weights['glitchAudio'] = basicProportion;
		weights['ruidoBlanco'] = strongProportion * 2;
	}
	// Waves 15-19: Add Eco Oscuro
	else if (waveNumber >= 15 && waveNumber <= 19) {
		weights['notaDesafinada'] = Math.round(weakEnemyProbability * 35);
		weights['glitchAudio'] = Math.round(weakEnemyProbability * 15);
		weights['ruidoBlanco'] = Math.round(strongEnemyProbability * 30);
		weights['ecoOscuro'] = Math.round(strongEnemyProbability * 20);
	}
	// Waves 20-24: Add Autotune Malicioso
	else if (waveNumber >= 20 && waveNumber <= 24) {
		weights['notaDesafinada'] = Math.round(weakEnemyProbability * 25);
		weights['glitchAudio'] = Math.round(weakEnemyProbability * 15);
		weights['ruidoBlanco'] = Math.round(strongEnemyProbability * 20);
		weights['ecoOscuro'] = Math.round(strongEnemyProbability * 20);
		weights['autotuneMalicioso'] = Math.round(strongEnemyProbability * 20);
	}
	// Wave 25+: All enemies with elite variants
	else {
		weights['notaDesafinada'] = 15;
		weights['glitchAudio'] = 15;
		weights['ruidoBlanco'] = 20;
		weights['ecoOscuro'] = 30;
		weights['autotuneMalicioso'] = 20;
	}
	return weights;
}
function spawnEnemy() {
	var availableTypes = getEnemyTypesForWave(wave);
	var weights = getEnemyTypeWeights(wave, availableTypes);
	// Calculate total weight
	var totalWeight = 0;
	for (var i = 0; i < availableTypes.length; i++) {
		totalWeight += weights[availableTypes[i]];
	}
	// Select random enemy type based on weights
	var random = Math.random() * totalWeight;
	var selectedType = availableTypes[0];
	var currentWeight = 0;
	for (var i = 0; i < availableTypes.length; i++) {
		currentWeight += weights[availableTypes[i]];
		if (random <= currentWeight) {
			selectedType = availableTypes[i];
			break;
		}
	}
	// Determine if this should be an elite enemy (earlier and higher chances)
	var isElite = false;
	if (wave >= 20) {
		isElite = Math.random() < 0.35; // 35% chance for elite from wave 20
	} else if (wave >= 15) {
		isElite = Math.random() < 0.20; // 20% chance for elite from wave 15
	} else if (wave >= 10) {
		isElite = Math.random() < 0.10; // 10% chance for elite from wave 10
	}
	// Special enemy mechanics from wave 8+
	var isSpecialEnemy = false;
	var specialType = '';
	if (wave >= 8 && Math.random() < 0.3) {
		// 30% chance for special enemy
		isSpecialEnemy = true;
		var specialTypes = ['spectral', 'explosive', 'disruptor', 'runner', 'armored'];
		if (wave >= 8 && wave < 12) specialTypes = ['spectral', 'runner'];else if (wave >= 12 && wave < 16) specialTypes = ['spectral', 'explosive', 'runner'];else if (wave >= 16) specialTypes = ['spectral', 'explosive', 'disruptor', 'runner', 'armored'];
		specialType = specialTypes[Math.floor(Math.random() * specialTypes.length)];
	}
	var enemy = new Enemy(selectedType, isElite, isSpecialEnemy, specialType);
	enemy.x = pathPoints[0].x;
	enemy.y = pathPoints[0].y;
	// Scale health based on wave - more aggressive scaling
	var healthMultiplier;
	if (wave <= 5) {
		healthMultiplier = Math.pow(1.15, wave - 1); // Increased from 1.12
	} else if (wave <= 15) {
		// More aggressive scaling from wave 6-15: vida = vida_base × (1.12)^wave
		healthMultiplier = Math.pow(1.12, wave);
	} else {
		// Even more aggressive for wave 16+: vida = vida_base × (1.14)^wave
		healthMultiplier = Math.pow(1.14, wave);
	}
	// Apply difficulty modifier for gold abuse punishment
	healthMultiplier *= difficultyModifier;
	enemy.health = Math.floor(enemy.health * healthMultiplier * 1.3); // Increased from 1.2
	enemy.maxHealth = enemy.health;
	// Apply speed modifier from wave 6+ (moved earlier)
	if (wave >= 6) {
		var speedIncrease = Math.floor((wave - 6) / 2) * 0.06; // 6% every 2 waves starting wave 6
		enemy.speed *= (1 + speedIncrease) * enemySpeedModifier;
	}
	// Additional speed boost for waves 15+
	if (wave >= 15) {
		enemy.speed *= 1.15; // 15% additional speed boost
	}
	enemies.push(enemy);
	game.addChild(enemy);
}
function startNextWave() {
	if (gameState === 'playing') {
		// Start background music on first wave
		if (wave === 1) {
			LK.stopMusic(); // Stop menu music
			gameplayMusicPlaying = false;
			playMelodia();
		} else if (!musicMuted && !gameplayMusicPlaying) {
			// Ensure music is playing for subsequent waves
			playMelodia();
		}
		// Set up the wave but don't start it yet
		wavePaused = true;
		autoStartTimer = 0;
		enemiesSpawned = 0;
		enemiesPerWave = calculateEnemiesForWave(wave); // Use calculated enemy count
		waveStarted = false;
		// Adjust max gold per wave based on progression
		if (wave >= 6) {
			maxGoldPerWave = 45; // Reduced from wave 6
		} else {
			maxGoldPerWave = 60; // Normal for early waves
		}
		// Further reduce for waves with punishment
		if (goldAbuseCooldown > 0) {
			maxGoldPerWave = Math.round(maxGoldPerWave * 0.7); // 30% reduction
		}
		// Show wave announcement
		var waveAnnouncement = game.addChild(new Text2('♪ WAVE ' + wave + ' READY ♪', {
			size: 120,
			fill: 0xFFD700,
			font: "'Blackletter', 'Old English Text MT', 'Germania One', serif"
		}));
		waveAnnouncement.anchor.set(0.5, 0.5);
		waveAnnouncement.x = 1024;
		waveAnnouncement.y = 1366;
		waveAnnouncement.alpha = 0;
		// Animate the announcement
		tween(waveAnnouncement, {
			alpha: 1,
			scaleX: 1.1,
			scaleY: 1.1
		}, {
			duration: 800,
			easing: tween.easeOut,
			onFinish: function onFinish() {
				tween(waveAnnouncement, {
					alpha: 0,
					scaleX: 0.9,
					scaleY: 0.9
				}, {
					duration: 1000,
					easing: tween.easeIn,
					onFinish: function onFinish() {
						waveAnnouncement.destroy();
					}
				});
			}
		});
		updateWaveUI();
	}
}
function startCurrentWave() {
	if (wavePaused && gameState === 'playing') {
		wavePaused = false;
		waveStarted = true;
		autoStartTimer = 0;
		// Play horn sound for wave start
		LK.getSound('Cuerno').play();
		// Show "GO!" message
		var goMessage = game.addChild(new Text2('♪ GO! ♪', {
			size: 150,
			fill: 0x00FF00,
			font: "'Blackletter', 'Old English Text MT', 'Germania One', serif"
		}));
		goMessage.anchor.set(0.5, 0.5);
		goMessage.x = 1024;
		goMessage.y = 1366;
		goMessage.alpha = 0;
		tween(goMessage, {
			alpha: 1,
			scaleX: 1.3,
			scaleY: 1.3
		}, {
			duration: 400,
			easing: tween.easeOut,
			onFinish: function onFinish() {
				tween(goMessage, {
					alpha: 0,
					scaleX: 0.8,
					scaleY: 0.8
				}, {
					duration: 600,
					easing: tween.easeIn,
					onFinish: function onFinish() {
						goMessage.destroy();
					}
				});
			}
		});
		updateWaveUI();
	}
}
function updateWaveUI() {
	if (wavePaused && autoStartTimer > 0) {
		var timeLeft = Math.ceil((300 - autoStartTimer) / 60); // 5 seconds = 300 ticks
		autoStartText.setText('Auto: ' + timeLeft + 's');
		startWaveText.setText('♪ START WAVE ♪');
		startWaveButton.tint = 0xFFFFFF;
	} else if (wavePaused) {
		autoStartText.setText('Auto: 5s');
		startWaveText.setText('♪ START WAVE ♪');
		startWaveButton.tint = 0xFFFFFF;
	} else {
		autoStartText.setText('In Progress');
		startWaveText.setText('♪ WAVE ACTIVE ♪');
		startWaveButton.tint = 0x666666;
	}
}
// Hide game elements initially
goal.visible = false;
buildMenuContainer.visible = false;
// Hide build spots initially
for (var i = 0; i < buildSpots.length; i++) {
	buildSpots[i].visible = false;
}
// Title intro system
var titleIntroContainer;
var leftCurtainIntro;
var rightCurtainIntro;
function showTitleIntro() {
	menuContainer.visible = false;
	gameState = 'titleIntro';
	// Play title sound
	LK.getSound('titleSound').play();
	// Create title intro container
	titleIntroContainer = new Container();
	game.addChild(titleIntroContainer);
	// Create closed curtains covering the entire screen
	leftCurtainIntro = titleIntroContainer.addChild(LK.getAsset('curtain', {
		anchorX: 1,
		anchorY: 0
	}));
	leftCurtainIntro.x = 1024; // Center of screen
	leftCurtainIntro.y = 0;
	leftCurtainIntro.scaleX = 1.8;
	leftCurtainIntro.scaleY = 3.0;
	rightCurtainIntro = titleIntroContainer.addChild(LK.getAsset('curtain', {
		anchorX: 0,
		anchorY: 0
	}));
	rightCurtainIntro.x = 1024; // Center of screen
	rightCurtainIntro.y = 0;
	rightCurtainIntro.scaleX = 1.8;
	rightCurtainIntro.scaleY = 3.0;
	// Create gothic title text
	var titleText = titleIntroContainer.addChild(new Text2('Symphony Siege', {
		size: 160,
		fill: 0xFFD700,
		font: "'Blackletter', 'Old English Text MT', 'Germania One', serif"
	}));
	titleText.anchor.set(0.5, 0.5);
	titleText.x = 1024;
	titleText.y = 1366;
	titleText.alpha = 0;
	// Animate title appearing
	tween(titleText, {
		alpha: 1,
		scaleX: 1.2,
		scaleY: 1.2
	}, {
		duration: 1000,
		easing: tween.easeOut,
		onFinish: function onFinish() {
			// After 2 seconds, open curtains
			LK.setTimeout(function () {
				openCurtainsAndStartGame();
			}, 1000);
		}
	});
}
function openCurtainsAndStartGame() {
	// Animate curtains opening
	tween(leftCurtainIntro, {
		x: -600
	}, {
		duration: 2000,
		easing: tween.easeInOut
	});
	tween(rightCurtainIntro, {
		x: 2648
	}, {
		duration: 2000,
		easing: tween.easeInOut,
		onFinish: function onFinish() {
			// Clean up title intro and start game
			titleIntroContainer.destroy();
			gameState = 'playing';
			startNextWave();
		}
	});
}
function showCreditsScreen() {
	showingCredits = true;
	gameState = 'credits';
	// Create credits container
	creditsContainer = new Container();
	game.addChild(creditsContainer);
	// Credits background
	var creditsBackground = creditsContainer.addChild(LK.getAsset('woodPanel', {
		anchorX: 0.5,
		anchorY: 0.5
	}));
	creditsBackground.x = 1024;
	creditsBackground.y = 1366;
	creditsBackground.scaleX = 4.5;
	creditsBackground.scaleY = 6;
	creditsBackground.alpha = 0.95;
	creditsBackground.tint = 0x2D1B0E;
	// Credits title
	var creditsTitle = creditsContainer.addChild(new Text2('♪ CREDITS ♪', {
		size: 120,
		fill: 0xFFD700,
		font: "'Blackletter', 'Old English Text MT', 'Germania One', serif"
	}));
	creditsTitle.anchor.set(0.5, 0.5);
	creditsTitle.x = 1024;
	creditsTitle.y = 400;
	// Attribution text for Udio music
	var attributionText = creditsContainer.addChild(new Text2('Music generated with Udio\n\nThis game includes AI-generated music\ncreated using Udio.\n\nAll tracks were produced by the developer\nvia Udio\'s platform under its current\nterms of use.', {
		size: 55,
		fill: 0xF5F5DC,
		font: "'Blackletter', 'Old English Text MT', 'Germania One', serif"
	}));
	attributionText.anchor.set(0.5, 0.5);
	attributionText.x = 1024;
	attributionText.y = 1000;
	// Continue button
	var continueButton = creditsContainer.addChild(LK.getAsset('trumpetTower', {
		anchorX: 0.5,
		anchorY: 0.5
	}));
	continueButton.x = 1024;
	continueButton.y = 1600;
	continueButton.scaleX = 1.2;
	continueButton.scaleY = 1.2;
	var continueButtonText = creditsContainer.addChild(new Text2('♪ CONTINUE ♪', {
		size: 65,
		fill: 0xFFD700,
		font: "'Blackletter', 'Old English Text MT', 'Germania One', serif"
	}));
	continueButtonText.anchor.set(0.5, 0.5);
	continueButtonText.x = 1024;
	continueButtonText.y = 1700;
	// Animate credits appearing
	creditsContainer.alpha = 0;
	tween(creditsContainer, {
		alpha: 1
	}, {
		duration: 1000,
		easing: tween.easeOut
	});
	// Continue button handler
	continueButton.down = function () {
		hideCreditsScreen();
	};
}
function enterGrandPianoTargetingMode() {
	if (grandPianoGhostMode) return;
	grandPianoGhostMode = true;
	hideUpgradeMenu();
	hideBuildMenu();
	// Create ghost piano that follows mouse
	grandPianoGhost = game.addChild(LK.getAsset('grandPianoGhost', {
		anchorX: 0.5,
		anchorY: 0.5
	}));
	grandPianoGhost.alpha = 0.6;
	grandPianoGhost.tint = 0x00FFFF;
	// Create targeting area indicator
	grandPianoTargetArea = game.addChild(LK.getAsset('grandPianoShadow', {
		anchorX: 0.5,
		anchorY: 0.5
	}));
	grandPianoTargetArea.alpha = 0.3;
	grandPianoTargetArea.tint = 0xFF0000;
	updateGrandPianoPowerUI();
}
function exitGrandPianoTargetingMode() {
	if (!grandPianoGhostMode) return;
	grandPianoGhostMode = false;
	if (grandPianoGhost) {
		grandPianoGhost.destroy();
		grandPianoGhost = null;
	}
	if (grandPianoTargetArea) {
		grandPianoTargetArea.destroy();
		grandPianoTargetArea = null;
	}
}
function activateGrandPianoPowerAt(targetX, targetY) {
	exitGrandPianoTargetingMode();
	activateGrandPianoPower(targetX, targetY);
}
function activateGrandPianoPower(targetX, targetY) {
	if (grandPianoPowerActive) return;
	grandPianoPowerActive = true;
	grandPianoCooldownRemaining = 5; // 5 wave cooldown
	updateGrandPianoPowerUI();
	// Use center of screen as default if no target provided
	var impactX = targetX || 1024;
	var impactY = targetY || 1366;
	// Play dramatic piano chord
	LK.getSound('grandPianoChord').play();
	// Create falling piano animation
	var fallingPiano = game.addChild(LK.getAsset('grandPianoFalling', {
		anchorX: 0.5,
		anchorY: 0.5
	}));
	fallingPiano.x = impactX;
	fallingPiano.y = -200; // Start above screen
	fallingPiano.rotation = 0.1;
	fallingPiano.alpha = 0.9;
	// Create piano keys falling effect around target area
	for (var i = 0; i < 12; i++) {
		var pianoKey = game.addChild(LK.getAsset('pianoKey', {
			anchorX: 0.5,
			anchorY: 0.5
		}));
		pianoKey.x = impactX - 200 + i * 35; // Centered around impact point
		pianoKey.y = -100 - Math.random() * 200;
		pianoKey.rotation = Math.random() * Math.PI;
		pianoKey.tint = i % 2 === 0 ? 0xFFFFFF : 0x000000;
		// Animate piano key falling
		tween(pianoKey, {
			y: 2800,
			rotation: pianoKey.rotation + Math.PI * 4,
			alpha: 0
		}, {
			duration: 2000 + Math.random() * 1000,
			easing: tween.easeIn,
			onFinish: function onFinish() {
				if (pianoKey.parent) {
					pianoKey.destroy();
				}
			}
		});
	}
	// Animate piano falling with dramatic effect
	tween(fallingPiano, {
		y: impactY,
		// Target position
		rotation: 0.3,
		scaleX: 1.5,
		scaleY: 1.5
	}, {
		duration: 1500,
		easing: tween.easeIn,
		onFinish: function onFinish() {
			// Piano impact effect
			LK.getSound('grandPianoImpact').play();
			// Screen shake effect
			tween(game, {
				x: 20
			}, {
				duration: 100,
				onFinish: function onFinish() {
					tween(game, {
						x: -20
					}, {
						duration: 100,
						onFinish: function onFinish() {
							tween(game, {
								x: 0
							}, {
								duration: 100
							});
						}
					});
				}
			});
			// Damage enemies within reduced area (120 pixels instead of all screen)
			var areaRadius = 120; // Reduced from affecting all enemies on screen
			var enemiesHit = 0;
			for (var i = enemies.length - 1; i >= 0; i--) {
				var enemy = enemies[i];
				// Check if enemy is within area of effect
				var dx = enemy.x - impactX;
				var dy = enemy.y - impactY;
				var distance = Math.sqrt(dx * dx + dy * dy);
				if (distance <= areaRadius) {
					// Scale damage based on wave: 300 + (wave * 25) for progression
					var scaledDamage = 300 + wave * 25;
					var died = enemy.takeDamage(scaledDamage);
					if (died) {
						// Calculate gold reward for enemies killed by Grand Piano
						var goldReward = enemy.goldValue;
						// Apply wave restrictions for gold
						if (wave >= 6) {
							goldReward = Math.min(goldReward, 3);
						}
						// Ensure minimum gold reward of 1 for all enemies from wave 10+
						if (wave >= 10 && goldReward === 0) {
							goldReward = 1;
						}
						// Check wave gold limit
						if (lastWaveGoldEarned + goldReward > maxGoldPerWave) {
							goldReward = Math.max(1, maxGoldPerWave - lastWaveGoldEarned);
						}
						// Apply gold reward
						if (goldReward > 0) {
							gold += goldReward;
							lastWaveGoldEarned += goldReward;
						}
						updateUI();
						LK.getSound('enemyDeath').play();
					} else {
						// Stun surviving enemies for 3 seconds
						enemy.grandPianoStunnedUntil = LK.ticks + 180; // 3 seconds at 60fps
						// Visual stun effect
						var enemyGraphics = enemy.getChildAt(0);
						if (enemyGraphics) {
							var originalTint = enemyGraphics.tint || 0xffffff;
							tween(enemyGraphics, {
								tint: 0xFFD700,
								// Gold stun effect
								scaleX: 0.7,
								scaleY: 0.7
							}, {
								duration: 300,
								easing: tween.easeOut,
								onFinish: function onFinish() {
									LK.setTimeout(function () {
										if (enemyGraphics && enemyGraphics.parent) {
											tween(enemyGraphics, {
												tint: originalTint,
												scaleX: 1.0,
												scaleY: 1.0
											}, {
												duration: 400
											});
										}
									}, 180 * 16); // Stun duration
								}
							});
						}
					}
					enemiesHit++;
				}
			}
			// Show impact effect at target location
			var impactEffect = game.addChild(LK.getAsset('spotlight', {
				anchorX: 0.5,
				anchorY: 0.5
			}));
			impactEffect.x = impactX;
			impactEffect.y = impactY;
			impactEffect.tint = 0xFFD700;
			impactEffect.alpha = 0.8;
			impactEffect.scaleX = 0.5;
			impactEffect.scaleY = 0.5;
			tween(impactEffect, {
				scaleX: 6,
				// Smaller impact effect to match reduced area
				scaleY: 6,
				alpha: 0
			}, {
				duration: 1000,
				easing: tween.easeOut,
				onFinish: function onFinish() {
					impactEffect.destroy();
				}
			});
			// Piano disappears after impact
			tween(fallingPiano, {
				alpha: 0,
				scaleY: 0.1,
				y: fallingPiano.y + 200
			}, {
				duration: 800,
				easing: tween.easeIn,
				onFinish: function onFinish() {
					fallingPiano.destroy();
					grandPianoPowerActive = false;
				}
			});
		}
	});
}
function updateGrandPianoPowerUI() {
	if (!grandPianoPowerUnlocked) {
		grandPianoButtonBackground.visible = false;
		grandPianoPowerButton.visible = false;
		grandPianoPowerText.visible = false;
		grandPianoCooldownText.visible = false;
		return;
	}
	grandPianoButtonBackground.visible = true;
	grandPianoPowerButton.visible = true;
	grandPianoPowerText.visible = true;
	grandPianoCooldownText.visible = true;
	if (grandPianoGhostMode) {
		grandPianoCooldownText.setText('Click to target!');
		grandPianoCooldownText.tint = 0x00FFFF;
		grandPianoPowerButton.tint = 0x00FFFF;
		grandPianoPowerButton.alpha = 1.0;
		// Add pulsing effect during targeting
		var pulseScale = 1.0 + Math.sin(LK.ticks * 0.2) * 0.1;
		grandPianoPowerButton.scaleX = pulseScale;
		grandPianoPowerButton.scaleY = pulseScale;
	} else if (grandPianoCooldownRemaining > 0) {
		grandPianoCooldownText.setText(grandPianoCooldownRemaining + ' waves left');
		grandPianoCooldownText.tint = 0xFF4444;
		grandPianoPowerButton.tint = 0x666666;
		grandPianoPowerButton.alpha = 0.6;
		grandPianoPowerButton.scaleX = 1.0;
		grandPianoPowerButton.scaleY = 1.0;
		// Visual cooldown progress - create loading circle effect
		var cooldownProgress = 1.0 - grandPianoCooldownRemaining / 5.0;
		var progressAngle = cooldownProgress * Math.PI * 2;
		grandPianoPowerButton.rotation = progressAngle;
	} else {
		grandPianoCooldownText.setText('Ready!');
		grandPianoCooldownText.tint = 0x00FF00;
		grandPianoPowerButton.tint = 0xFFFFFF;
		grandPianoPowerButton.alpha = 1.0;
		grandPianoPowerButton.scaleX = 1.0;
		grandPianoPowerButton.scaleY = 1.0;
		grandPianoPowerButton.rotation = 0;
	}
}
function showGrandPianoUnlockAnimation() {
	// Create chest that appears in center of screen
	var musicChest = game.addChild(LK.getAsset('musicChest', {
		anchorX: 0.5,
		anchorY: 0.5
	}));
	musicChest.x = 1024;
	musicChest.y = 1366;
	musicChest.scaleX = 2.0;
	musicChest.scaleY = 2.0;
	musicChest.alpha = 0;
	musicChest.tint = 0x8B4513;
	// Chest appears with light effect
	var chestLight = game.addChild(LK.getAsset('spotlight', {
		anchorX: 0.5,
		anchorY: 0.5
	}));
	chestLight.x = 1024;
	chestLight.y = 1366;
	chestLight.tint = 0xFFD700;
	chestLight.alpha = 0;
	chestLight.scaleX = 3;
	chestLight.scaleY = 3;
	// Animate chest appearing
	tween(musicChest, {
		alpha: 1,
		scaleX: 2.5,
		scaleY: 2.5
	}, {
		duration: 1000,
		easing: tween.easeOut
	});
	tween(chestLight, {
		alpha: 0.6
	}, {
		duration: 1000,
		easing: tween.easeOut,
		onFinish: function onFinish() {
			// Chest opens with sound
			LK.getSound('chestOpen').play();
			// Create golden particles exploding from chest
			for (var i = 0; i < 20; i++) {
				var particle = game.addChild(LK.getAsset('goldenParticle', {
					anchorX: 0.5,
					anchorY: 0.5
				}));
				particle.x = 1024;
				particle.y = 1366;
				particle.tint = 0xFFD700;
				particle.scaleX = 0.5;
				particle.scaleY = 0.5;
				var angle = Math.PI * 2 * i / 20;
				var speed = 200 + Math.random() * 150;
				var targetX = 1024 + Math.cos(angle) * speed;
				var targetY = 1366 + Math.sin(angle) * speed;
				tween(particle, {
					x: targetX,
					y: targetY,
					scaleX: 1.5,
					scaleY: 1.5,
					alpha: 0
				}, {
					duration: 1500,
					easing: tween.easeOut,
					onFinish: function onFinish() {
						particle.destroy();
					}
				});
			}
			// Grand Piano emerges from chest
			LK.setTimeout(function () {
				var emergingPiano = game.addChild(LK.getAsset('grandPiano', {
					anchorX: 0.5,
					anchorY: 1
				}));
				emergingPiano.x = 1024;
				emergingPiano.y = 1366;
				emergingPiano.scaleX = 0.1;
				emergingPiano.scaleY = 0.1;
				emergingPiano.alpha = 0;
				emergingPiano.rotation = Math.PI * 2;
				// Play fanfare music
				LK.playMusic('fanfare', {
					loop: false
				});
				// Piano emerges and floats upward with light from below
				var pianoLight = game.addChild(LK.getAsset('spotlight', {
					anchorX: 0.5,
					anchorY: 0.5
				}));
				pianoLight.x = 1024;
				pianoLight.y = 1500;
				pianoLight.tint = 0x00FFFF;
				pianoLight.alpha = 0;
				pianoLight.scaleX = 2;
				pianoLight.scaleY = 4;
				tween(pianoLight, {
					alpha: 0.8
				}, {
					duration: 2000
				});
				tween(emergingPiano, {
					alpha: 1,
					scaleX: 1.5,
					scaleY: 1.5,
					y: 1200,
					rotation: 0
				}, {
					duration: 2000,
					easing: tween.easeOut,
					onFinish: function onFinish() {
						// Piano moves to its UI position
						var targetX = grandPianoPowerButton.x + 200;
						var targetY = grandPianoPowerButton.y - 400;
						tween(emergingPiano, {
							x: targetX,
							y: targetY,
							scaleX: 1.0,
							scaleY: 1.0
						}, {
							duration: 1500,
							easing: tween.easeInOut,
							onFinish: function onFinish() {
								// Unlock power and show UI
								grandPianoPowerUnlocked = true;
								updateGrandPianoPowerUI();
								// Show unlock message
								var unlockMsg = game.addChild(new Text2('♪ GRAND PIANO POWER UNLOCKED! ♪\nTarget and unleash devastating musical might!', {
									size: 70,
									fill: 0xFFD700,
									font: "'Blackletter', 'Old English Text MT', 'Germania One', serif"
								}));
								unlockMsg.anchor.set(0.5, 0.5);
								unlockMsg.x = 1024;
								unlockMsg.y = 1000;
								unlockMsg.alpha = 0;
								tween(unlockMsg, {
									alpha: 1
								}, {
									duration: 1000,
									easing: tween.easeOut,
									onFinish: function onFinish() {
										LK.setTimeout(function () {
											tween(unlockMsg, {
												alpha: 0
											}, {
												duration: 1000,
												onFinish: function onFinish() {
													unlockMsg.destroy();
												}
											});
										}, 3000);
									}
								});
								// Clean up animation objects
								emergingPiano.destroy();
								pianoLight.destroy();
								chestLight.destroy();
								musicChest.destroy();
							}
						});
					}
				});
			}, 1000);
		}
	});
}
function hideCreditsScreen() {
	showingCredits = false;
	// Animate credits disappearing
	tween(creditsContainer, {
		alpha: 0
	}, {
		duration: 500,
		easing: tween.easeIn,
		onFinish: function onFinish() {
			creditsContainer.destroy();
			gameState = 'playing';
			// Now advance to wave 101
			wave++;
			waveStarted = false;
			gold += 75; // Bonus gold for completing wave
			updateUI();
			// Continue with normal wave progression
			LK.setTimeout(function () {
				startNextWave();
			}, 1000);
		}
	});
}
// Show main menu first
gameState = 'menu';
// Play Voz sound immediately when entering initial menu and chain Risa after it finishes
var vozSound = LK.getSound('Voz');
vozSound.play();
// Calculate duration of Voz sound and play Risa after that duration
// Assuming Voz sound is approximately 3 seconds, adjust timing as needed
LK.setTimeout(function () {
	LK.getSound('Risa').play();
}, 3000); // 3 seconds delay, adjust based on actual Voz sound duration
// Play menu music
if (!musicMuted) {
	LK.playMusic('MusicaInicio', {
		loop: true
	});
}
game.update = function () {
	// Concert hall ambiance - create floating musical notes periodically
	if (LK.ticks % 180 === 0) {
		// Every 3 seconds
		createFloatingNote();
	}
	// Simple Music System - ensure Melodia is playing during gameplay
	if (gameState === 'playing' && !musicMuted) {
		// Check if music needs to be started or restarted (every 5 seconds)
		if (LK.ticks % 300 === 0) {
			if (!gameplayMusicPlaying) {
				console.log("Music not playing, starting Melodia");
				playMelodia();
			}
		}
	}
	if (gameState === 'playing') {
		// Handle Grand Piano targeting mode cleanup if game state changes
		if (grandPianoGhostMode && (gameState !== 'playing' || showingBuildMenu || showingUpgradeMenu)) {
			exitGrandPianoTargetingMode();
		}
		// Show game elements when playing
		goal.visible = true;
		// Show build spots
		for (var i = 0; i < buildSpots.length; i++) {
			buildSpots[i].visible = true;
		}
		// Spawn enemies
		if (waveStarted && enemiesSpawned < enemiesPerWave) {
			spawnTimer++;
			var spawnInterval = getSpawnIntervalForWave(wave);
			if (spawnTimer >= spawnInterval) {
				spawnEnemy();
				enemiesSpawned++;
				spawnTimer = 0;
			}
		}
		// Handle wave auto-start timer
		if (wavePaused && enemies.length === 0) {
			autoStartTimer++;
			if (autoStartTimer >= 300) {
				// 5 seconds at 60fps
				startCurrentWave();
			}
			// Update UI every 60 ticks (1 second)
			if (autoStartTimer % 60 === 0) {
				updateWaveUI();
			}
		}
		// Check if wave is complete
		if (waveStarted && enemiesSpawned >= enemiesPerWave && enemies.length === 0) {
			// Check if player has lives before advancing
			if (lives <= 0) {
				LK.showGameOver();
				return;
			}
			// Show credits screen after wave 100
			if (wave === 100) {
				showCreditsScreen();
				return; // Don't advance wave yet, credits will handle it
			}
			wave++;
			waveStarted = false;
			gold += 75; // Bonus gold for completing wave
			updateUI();
			// Unlock Grand Piano power after wave 10
			if (wave === 11 && !grandPianoPowerUnlocked && !grandPianoUnlockAnimationShown) {
				grandPianoUnlockAnimationShown = true;
				showGrandPianoUnlockAnimation();
			}
			// Reduce Grand Piano cooldown
			if (grandPianoCooldownRemaining > 0) {
				grandPianoCooldownRemaining--;
				updateGrandPianoPowerUI();
			}
			// Ensure Melodia continues playing
			if (wave === 16 && !musicMuted && !gameplayMusicPlaying) {
				playMelodia(); // Ensure Melodia is still playing
			}
			// Reset wave gold tracking
			lastWaveGoldEarned = 0;
			// Check for gold abuse (maintaining >600 gold)
			if (gold > 600) {
				highGoldWaveCount++;
				if (highGoldWaveCount >= 3) {
					// Activate punishment modifier
					difficultyModifier = 1.5; // 50% more health for next 2 waves
					enemySpeedModifier = 1.3; // 30% faster enemies
					goldAbuseCooldown = 2; // Lasts for 2 waves
					highGoldWaveCount = 0;
					// Show warning message
					var warningMsg = game.addChild(new Text2('⚠ DIFFICULTY INCREASED ⚠\nToo much gold hoarded!', {
						size: 80,
						fill: 0xFF0000,
						font: "'Blackletter', 'Old English Text MT', 'Germania One', serif"
					}));
					warningMsg.anchor.set(0.5, 0.5);
					warningMsg.x = 1024;
					warningMsg.y = 1000;
					tween(warningMsg, {
						alpha: 0
					}, {
						duration: 3000,
						onFinish: function onFinish() {
							warningMsg.destroy();
						}
					});
				}
			} else {
				highGoldWaveCount = 0;
			}
			// Decrement punishment cooldown
			if (goldAbuseCooldown > 0) {
				goldAbuseCooldown--;
				if (goldAbuseCooldown === 0) {
					difficultyModifier = 1.0;
					enemySpeedModifier = 1.0;
				}
			}
			// Check for forced expense events every 5 waves
			if (wave % 5 === 0 && wave >= 5) {
				forceExpenseEvent = true;
				var expenseAmount = Math.floor(gold * 0.3); // 30% of current gold
				gold = Math.max(gold - expenseAmount, 50); // Minimum 50 gold left
				var expenseMsg = game.addChild(new Text2('♪ MANDATORY REPAIRS ♪\n-$' + expenseAmount + ' for hall maintenance', {
					size: 70,
					fill: 0xFFD700,
					font: "'Blackletter', 'Old English Text MT', 'Germania One', serif"
				}));
				expenseMsg.anchor.set(0.5, 0.5);
				expenseMsg.x = 1024;
				expenseMsg.y = 1200;
				tween(expenseMsg, {
					alpha: 0
				}, {
					duration: 4000,
					onFinish: function onFinish() {
						expenseMsg.destroy();
					}
				});
				updateUI();
			}
			// Start next wave after delay
			LK.setTimeout(function () {
				startNextWave();
			}, 3000);
		}
	}
	// Clean up destroyed bullets
	for (var i = bullets.length - 1; i >= 0; i--) {
		if (bullets[i].destroyed) {
			bullets.splice(i, 1);
		}
	}
	// Clean up dead enemies
	for (var i = enemies.length - 1; i >= 0; i--) {
		if (enemies[i].health <= 0) {
			enemies[i].destroy();
			enemies.splice(i, 1);
		}
	}
};

===================================================================
--- original.js
+++ change.js
@@ -1886,9 +1886,9 @@
 LK.gui.topRight.addChild(goldIcon);
 goldIcon.x = -280;
 goldIcon.y = 100;
 var goldText = new Text2(gold, {
-	size: 120,
+	size: 80,
 	fill: 0xFFD700,
 	font: "'Blackletter', 'Old English Text MT', 'Germania One', serif"
 });
 goldText.anchor.set(0.5, 0.5);