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

/**** 
* Classes
****/ 
var ElementalNote = Container.expand(function (element, x, y) {
	var self = Container.call(this);
	var noteGraphics = self.attachAsset(element + 'Note', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.element = element;
	self.x = x;
	self.y = y;
	var label = new Text2(element.toUpperCase(), {
		size: 30,
		fill: 0xFFFFFF
	});
	label.anchor.set(0.5, 0.5);
	self.addChild(label);
	self.isDisabled = false;
	self.down = function (x, y, obj) {
		// Check if button is disabled
		if (self.isDisabled) {
			return;
		}
		// Disable button
		self.isDisabled = true;
		notePressed(self.element);
		// Play sound effect with controlled volume when pressed directly
		// Access current global soundValue instead of captured value
		var currentSoundValue = typeof soundValue !== 'undefined' ? soundValue : 0.8;
		if (self.element === 'fire') {
			var fireSound = LK.getSound('Nota_Fire');
			fireSound.volume = currentSoundValue * 0.5;
			fireSound.play();
		} else if (self.element === 'water') {
			var waterSound = LK.getSound('Nota_Water');
			waterSound.volume = currentSoundValue;
			waterSound.play();
		} else if (self.element === 'earth') {
			var earthSound = LK.getSound('Nota_Earth');
			earthSound.volume = currentSoundValue;
			earthSound.play();
		} else if (self.element === 'wind') {
			var windSound = LK.getSound('Nota_Wind');
			windSound.volume = currentSoundValue;
			windSound.play();
		} else if (self.element === 'light') {
			var lightSound = LK.getSound('Nota_Light');
			lightSound.volume = currentSoundValue;
			lightSound.play();
		} else {
			var summonSound = LK.getSound('summon');
			summonSound.volume = currentSoundValue;
			summonSound.play();
		}
		// Visual feedback - make smaller on press and change to green
		tween(noteGraphics, {
			scaleX: 0.8,
			scaleY: 0.8,
			tint: 0x00ff00
		}, {
			duration: 100,
			onFinish: function onFinish() {
				// Return to normal size and restore color quickly
				tween(noteGraphics, {
					scaleX: 1.0,
					scaleY: 1.0,
					tint: 0xffffff
				}, {
					duration: 100,
					onFinish: function onFinish() {
						// Only re-enable button if we have enough mana and haven't reached limit
						LK.setTimeout(function () {
							// Check if we still have enough mana and haven't reached the counter limit
							if (temporaryNoteCounter < currentMana) {
								self.isDisabled = false;
							}
						}, 0); // Re-enable conditionally after color animation
					}
				});
			}
		});
	};
	return self;
});
var Enemy = Container.expand(function () {
	var self = Container.call(this);
	var enemyGraphics = self.attachAsset('enemyUnit', {
		anchorX: 0.5,
		anchorY: 0.5,
		width: 280,
		height: 280
	});
	self.health = 80;
	self.maxHealth = 80;
	self.damage = 1;
	self.speed = 1.5;
	self.aumento_velocidad = 0;
	self.attackCooldown = 0;
	self.movimiento_enemigo = true; // Boolean to control enemy movement
	self.enemigo_oro = true; // Boolean to control golden statue state - start active
	self.isSleeping = true; // Individual sleep state - start active
	self.ataque_jugador = true; // Boolean to control if enemy can attack
	// Physics properties
	self.velocityY = 0;
	self.onGround = false;
	self.gravity = 0.5;
	// Beat effect properties
	self.baseY = 0;
	self.beatEffectTimer = 0;
	// Health bar
	var healthBar = LK.getAsset('healthBar', {
		width: 100,
		height: 12
	});
	healthBar.anchor.set(0.5, 0.5);
	healthBar.y = -80;
	self.addChild(healthBar);
	self.healthBar = healthBar;
	// Stats text below enemy
	var statsText = new Text2('', {
		size: 48,
		fill: 0xFFFFFF,
		font: "'GillSans-Bold',Impact,'Arial Black',Tahoma"
	});
	statsText.anchor.set(0.5, 0.5);
	statsText.y = 120; // Position below the enemy
	self.addChild(statsText);
	self.statsText = statsText;
	// Initialize miniola_colision property
	self.miniola_colision = false;
	// Function to update stats display
	self.updateStatsDisplay = function () {
		var totalSpeed = self.speed + self.aumento_velocidad;
		var statsString = self.health + '-' + self.damage + '-' + totalSpeed + '-' + (self.isSleeping || false) + '-' + self.enemigo_oro;
		self.statsText.setText(statsString);
	};
	// Initialize stats display
	self.updateStatsDisplay();
	self.update = function () {
		// Check emerald state first, then sleep within emerald
		if (self.enemigo_oro) {
			// Emerald state active - disable movement and attack
			self.movimiento_enemigo = false;
			self.ataque_jugador = false;
			// Check if also sleeping while emerald
			if (self.isSleeping) {
				// Both emerald and sleeping - apply black tint and wake-up timer
				enemyGraphics.tint = 0x000000; // Pure black tint for combined effect
				// Call despertar function after applying black tint
				despertar(self);
			} else {
				// Only emerald state - apply green tint
				enemyGraphics.tint = 0x00FF00; // Pure green color (emerald statue effect)
			}
		} else {
			// Not emerald - enable movement and attack
			self.movimiento_enemigo = true;
			self.ataque_jugador = true;
			// Reset tint if needed
			if (enemyGraphics.tint === 0x000000 || enemyGraphics.tint === 0xFFD700 || enemyGraphics.tint === 0xFFFF00 || enemyGraphics.tint === 0xFF0000 || enemyGraphics.tint === 0x00FF00 || enemyGraphics.tint === 0x333333) {
				enemyGraphics.tint = 0xffffff;
			}
		}
		// Movement is now controlled by movimiento_enemigo variable above
		// Check for warriors to attack and combat engagement
		var inCombat = false;
		for (var i = 0; i < warriors.length; i++) {
			var warrior = warriors[i];
			// Use half width for enemy and warrior colliders but keep full height
			var enemyColliderWidth = 280 * 0.5; // Half of enemy width
			var warriorColliderWidth = 288 * 0.5; // Half of warrior width
			var distance = Math.sqrt(Math.pow(self.x - warrior.x, 2) + Math.pow(self.y - warrior.y, 2));
			if (distance < 250) {
				// Mark as in combat to stop movement
				inCombat = true;
				// Attack if cooldown is ready and can attack
				if (self.attackCooldown <= 0 && self.ataque_jugador) {
					self.attack(warrior);
					// Play combat sound when fighting with warrior
					playRandomCombatSound();
					// Attack animation - flash red and scale up
					tween(enemyGraphics, {
						tint: 0xff0000,
						scaleX: 1.3,
						scaleY: 1.3
					}, {
						duration: 200,
						onFinish: function onFinish() {
							tween(enemyGraphics, {
								tint: 0xffffff,
								scaleX: 1.0,
								scaleY: 1.0
							}, {
								duration: 200
							});
						}
					});
				}
				break;
			}
		}
		// Set movimiento_enemigo based on combat state, statue status, and dormido state
		if (inCombat) {
			self.movimiento_enemigo = false; // Stop movement when attacking
		} else if (!self.enemigo_oro) {
			self.movimiento_enemigo = true; // Allow movement when not in combat, not a statue, and not sleeping
		}
		// Move towards player tower only if movement is enabled
		if (self.movimiento_enemigo) {
			// Move towards player tower (speed is controlled by combat state)
			var totalSpeed = self.speed + self.aumento_velocidad;
			self.x -= totalSpeed;
		}
		// Check if enemy is at the tower x position - stop movement to focus on tower attack
		var atTowerPosition = Math.abs(self.x - enemyTower.x) <= 50;
		// Control speed based on combat and tower position
		if (inCombat || atTowerPosition) {
			self.speed = 0;
			self.movimiento_enemigo = false; // Stop movement when at tower position or in combat
		} else {
			self.speed = 1.5;
			self.movimiento_enemigo = true; // Allow movement when not in combat or at tower
		}
		// Check collision with player tower and destroy enemy - use half width for enemy collider
		var towerColliderRadius = 700; // Fixed collider size, not scaled with tower
		var enemyColliderWidth = 280 * 0.5; // Half of enemy width
		var enemyColliderHeight = 280; // Full enemy height
		var towerDistance = Math.sqrt(Math.pow(self.x - playerTower.x, 2) + Math.pow(self.y - playerTower.y, 2));
		if (towerDistance < towerColliderRadius) {
			if (self.attackCooldown <= 0 && self.ataque_jugador) {
				self.attackPlayerTower();
			}
			// Destroy enemy when it touches the tower
			self.destroy();
			var index = enemies.indexOf(self);
			if (index > -1) {
				enemies.splice(index, 1);
			}
		}
		// Check if enemy is off-screen and destroy
		if (self.x < -500 || self.x > 4500 || self.y > 3500) {
			self.destroy();
			var index = enemies.indexOf(self);
			if (index > -1) {
				enemies.splice(index, 1);
			}
			return; // Exit update to prevent further execution
		}
		// Update health bar
		var healthPercent = self.health / self.maxHealth;
		self.healthBar.scaleX = healthPercent;
	};
	self.attack = function (target) {
		self.attackCooldown = 80;
		if (target === playerTower) {
			self.attackPlayerTower();
		} else {
			target.takeDamage(self.damage);
		}
	};
	self.attackPlayerTower = function () {
		self.attackCooldown = 80;
		playerTowerHealth -= self.damage;
		// Play random tower damage sound
		var towerSounds = ['sonido_torre_1', 'sonido_torre_2', 'sonido_torre_3', 'sonido_torre_4'];
		var randomIndex = Math.floor(Math.random() * towerSounds.length);
		var sound = LK.getSound(towerSounds[randomIndex]);
		sound.volume = soundValue;
		sound.play();
		// Create escombros particles when tower takes damage - quantity based on damage
		var particleCount = self.damage * 12; // Multiply particle count by damage
		for (var escombrosIndex = 0; escombrosIndex < particleCount; escombrosIndex++) {
			// 360-degree explosion pattern
			var angle = escombrosIndex / particleCount * Math.PI * 2; // Distribute evenly in 360 degrees
			var force = (200 + Math.random() * 300) * 4; // Quadruple the force
			var velocityX = Math.cos(angle) * force;
			var velocityY = Math.sin(angle) * force;
			var escombrosParticle = game.addChild(LK.getAsset('escombro_torre_jugador', {
				anchorX: 0.5,
				anchorY: 0.5,
				x: playerTower.x,
				y: playerTower.y - 800,
				width: (60 + Math.random() * 40) * 5,
				height: (60 + Math.random() * 40) * 5,
				rotation: Math.random() * Math.PI * 2
			}));
			escombrosParticle.alpha = 0.9;
			escombrosParticle.tint = 0x8B4513; // Brown color for debris
			// Add gravity and physics properties
			escombrosParticle.velocityX = velocityX * 0.02; // Scale down for smooth movement
			escombrosParticle.velocityY = velocityY * 0.02;
			escombrosParticle.gravity = 0.8; // Gravity effect
			// Animate escombros particles with physics
			tween(escombrosParticle, {
				y: playerTower.y + 200 + escombrosParticle.velocityY * 100,
				x: playerTower.x + escombrosParticle.velocityX * 100,
				alpha: 0,
				rotation: escombrosParticle.rotation + Math.PI * 4,
				scaleX: 0.1,
				scaleY: 0.1
			}, {
				duration: 2000 + Math.random() * 1000,
				easing: tween.easeOut,
				onFinish: function onFinish() {
					escombrosParticle.destroy();
				}
			});
		}
		if (playerTowerHealth <= 0) {
			LK.showGameOver();
		}
		updateTowerHealthBars();
	};
	self.takeBurnDamage = function (initialDamage, duration, burnDamage) {
		// Apply initial damage
		self.takeDamage(initialDamage);
		// Don't apply burn if enemy is already dead
		if (self.health <= 0) {
			return;
		}
		// Start burn sound loop - store sound instance for stopping later
		var burnSound = LK.getSound('burn_sound');
		burnSound.volume = soundValue * 0.8;
		self.burnSoundInstance = burnSound;
		burnSound.play();
		// Set up sound looping
		var soundLoopTimer = LK.setInterval(function () {
			if (self.health > 0 && self.burnSoundInstance) {
				self.burnSoundInstance.play();
			}
		}, 1000); // Loop every second
		// Add red tint at 80% opacity when burned
		tween(enemyGraphics, {
			tint: 0xff0000
		}, {
			duration: 200,
			onFinish: function onFinish() {
				// Keep 80% red tint during burn
				var redTint = 0xff3333; // 80% red color
				tween(enemyGraphics, {
					tint: redTint
				}, {
					duration: 100
				});
			}
		});
		// Apply burn effect over time
		var burnTicks = duration / 1000 * 60; // Convert duration to ticks (60fps)
		var burnInterval = 60; // Damage every second
		var ticksPerBurn = 0;
		var _burnEffect = function burnEffect() {
			ticksPerBurn++;
			if (ticksPerBurn >= burnInterval) {
				if (self.health > 0) {
					self.takeDamage(burnDamage);
					// Visual burn effect
					if (self.children[0]) {
						tween(self.children[0], {
							tint: 0xff4400
						}, {
							duration: 200,
							onFinish: function onFinish() {
								if (self.children[0]) {
									tween(self.children[0], {
										tint: 0xff3333
									}, {
										duration: 200
									});
								}
							}
						});
					}
				}
				ticksPerBurn = 0;
				burnTicks -= burnInterval;
			}
			if (burnTicks > 0 && self.health > 0) {
				LK.setTimeout(_burnEffect, 16); // ~60fps
			} else {
				// Burn effect ended, stop sound loop and restore normal color
				LK.clearInterval(soundLoopTimer);
				self.burnSoundInstance = null;
				tween(enemyGraphics, {
					tint: 0xffffff
				}, {
					duration: 500
				});
			}
		};
		_burnEffect();
	};
	self.takeDamage = function (damage) {
		self.health -= damage;
		// Update stats display to show current health
		self.updateStatsDisplay();
		if (self.health <= 0) {
			// Play enemy death sound
			var sound = LK.getSound('enemy_death');
			sound.volume = soundValue;
			sound.play();
			// Death animation - fade out and scale down
			tween(enemyGraphics, {
				alpha: 0,
				scaleX: 0.1,
				scaleY: 0.1,
				rotation: Math.PI * 2
			}, {
				duration: 500,
				easing: tween.easeOut,
				onFinish: function onFinish() {
					self.destroy();
				}
			});
			var index = enemies.indexOf(self);
			if (index > -1) {
				enemies.splice(index, 1);
			}
			LK.setScore(LK.getScore() + 10);
			scoreText.setText('Score: ' + LK.getScore());
			// 50% chance to drop mana if not at max capacity
			if (Math.random() < 0.5 && currentMana < maxMana) {
				// Create mana drop at enemy position
				var manaDrop = game.addChild(LK.getAsset('manaOrb', {
					anchorX: 0.5,
					anchorY: 0.5,
					x: self.x,
					y: self.y
				}));
				// Visual effect - pulsing and floating up
				tween(manaDrop, {
					scaleX: 3.0,
					scaleY: 3.0,
					y: self.y - 100
				}, {
					duration: 800,
					easing: tween.easeOut
				});
				// Add mana after short delay and destroy drop
				LK.setTimeout(function () {
					currentMana = Math.min(currentMana + 1, maxMana);
					updateManaDisplay();
					// Flash effect on collection
					tween(manaDrop, {
						alpha: 0,
						scaleX: 4,
						scaleY: 4
					}, {
						duration: 300,
						onFinish: function onFinish() {
							manaDrop.destroy();
						}
					});
				}, 600);
			}
		}
	};
	return self;
});
var Espora = Container.expand(function (targetWarrior) {
	var self = Container.call(this);
	var esporaGraphics = self.attachAsset('esporas', {
		anchorX: 0.5,
		anchorY: 0.5,
		width: 100,
		height: 100
	});
	self.targetWarrior = targetWarrior;
	self.velocityX = (Math.random() - 0.5) * 1; // Minimal random horizontal velocity
	self.velocityY = -2 - Math.random() * 3; // Initial upward velocity
	self.gravity = 0.1; // Reduced gravity force
	self.lifespan = 300; // 5 seconds at 60fps
	self.age = 0;
	// Set initial position near target warrior
	self.x = targetWarrior.x + (Math.random() - 0.5) * 100;
	self.y = targetWarrior.y + (Math.random() - 0.5) * 50;
	self.update = function () {
		self.age++;
		// Apply gravity
		self.velocityY += self.gravity;
		// Update position
		self.x += self.velocityX;
		self.y += self.velocityY;
		// Follow target warrior with gentle attraction
		if (self.targetWarrior && !self.targetWarrior.isBeingDestroyed) {
			var distanceToTarget = Math.sqrt(Math.pow(self.targetWarrior.x - self.x, 2) + Math.pow(self.targetWarrior.y - self.y, 2));
			if (distanceToTarget > 100) {
				// Gently drift towards warrior
				var directionX = (self.targetWarrior.x - self.x) / distanceToTarget;
				var directionY = (self.targetWarrior.y - self.y) / distanceToTarget;
				self.velocityX += directionX * 0.05; // Reduced attraction force
				self.velocityY += directionY * 0.05; // Reduced attraction force
			}
		}
		// Apply air resistance to reduce horizontal drift
		self.velocityX *= 0.95; // Air resistance dampens horizontal movement
		// Ground collision
		var groundY = 2186;
		if (self.y >= groundY) {
			self.y = groundY;
			self.velocityY = -self.velocityY * 0.3; // Bounce with energy loss
			self.velocityX *= 0.7; // Increased friction on ground contact
		}
		// Fade out over lifetime
		var fadeAlpha = 1.0 - self.age / self.lifespan;
		esporaGraphics.alpha = Math.max(0, fadeAlpha);
		// Check collision with enemies
		for (var e = 0; e < enemies.length; e++) {
			var enemy = enemies[e];
			var distance = Math.sqrt(Math.pow(self.x - enemy.x, 2) + Math.pow(self.y - enemy.y, 2));
			if (distance < 80) {
				// Collision detected
				// Deal damage to enemy
				enemy.takeDamage(3);
				// Emerald statue effect removed - spores only deal damage now
				// Create visual effect at collision point
				var explosion = game.addChild(LK.getAsset('explosion_fuego', {
					anchorX: 0.5,
					anchorY: 0.5,
					x: self.x,
					y: self.y,
					width: 120,
					height: 120
				}));
				explosion.tint = 0x44ff44; // Green color for spore explosion
				explosion.alpha = 0.8;
				// Animate explosion
				tween(explosion, {
					scaleX: 2.5,
					scaleY: 2.5,
					alpha: 0
				}, {
					duration: 600,
					easing: tween.easeOut,
					onFinish: function onFinish() {
						explosion.destroy();
					}
				});
				// Create spore particles around impact
				for (var p = 0; p < 8; p++) {
					var angle = p / 8 * Math.PI * 2;
					var particleDistance = 60 + Math.random() * 40;
					var particleX = self.x + Math.cos(angle) * particleDistance;
					var particleY = self.y + Math.sin(angle) * particleDistance;
					var particle = game.addChild(LK.getAsset('esporas', {
						anchorX: 0.5,
						anchorY: 0.5,
						x: self.x,
						y: self.y,
						width: 40 + Math.random() * 20,
						height: 40 + Math.random() * 20
					}));
					particle.tint = 0x88ff88;
					particle.alpha = 0.9;
					tween(particle, {
						x: particleX,
						y: particleY,
						alpha: 0,
						scaleX: 0.3,
						scaleY: 0.3
					}, {
						duration: 500 + Math.random() * 300,
						easing: tween.easeOut,
						onFinish: function onFinish() {
							particle.destroy();
						}
					});
				}
				// Destroy spore after collision
				self.destroy();
				var index = esporas.indexOf(self);
				if (index > -1) {
					esporas.splice(index, 1);
				}
				return; // Exit update after collision
			}
		}
		// Destroy after lifespan
		if (self.age >= self.lifespan) {
			self.destroy();
			var index = esporas.indexOf(self);
			if (index > -1) {
				esporas.splice(index, 1);
			}
		}
	};
	return self;
});
var Meteorito = Container.expand(function () {
	var self = Container.call(this);
	var meteoritoGraphics = self.attachAsset('meteorito_elemental', {
		anchorX: 0.5,
		anchorY: 0.5,
		scaleX: 6.0,
		scaleY: 6.0
	});
	self.speed = 20;
	self.rotationSpeed = 0.1;
	// Store the base scale to prevent shrinking
	self.baseScale = 6.0;
	// Rainbow cycling effect for mixed element meteorite
	meteoritoGraphics.tint = 0xffffff;
	// Add rainbow cycling animation
	var rainbowColors = [0xff4400, 0x1e90ff, 0x8b4513, 0x44ff44, 0xffff00];
	var colorIndex = 0;
	var colorTimer = 0;
	self.updateRainbow = function () {
		colorTimer++;
		if (colorTimer >= 10) {
			// Change color every 10 frames
			colorTimer = 0;
			colorIndex = (colorIndex + 1) % rainbowColors.length;
			meteoritoGraphics.tint = rainbowColors[colorIndex];
		}
	};
	// Meteorite maintains full opacity (no alpha animation)
	meteoritoGraphics.alpha = 1.0;
	self.update = function () {
		// Calculate target position (center of map at ground level)
		var targetX = 1920; // Center of the game map (3840/2)
		var targetY = 2186; // Ground level
		// Calculate direction vector toward target
		var deltaX = targetX - self.x;
		var deltaY = targetY - self.y;
		var distance = Math.sqrt(deltaX * deltaX + deltaY * deltaY);
		// Move diagonally toward target - double speed
		if (distance > self.speed) {
			// Normalize direction and apply double speed
			var directionX = deltaX / distance;
			var directionY = deltaY / distance;
			self.x += directionX * self.speed;
			self.y += directionY * self.speed;
		} else {
			// Reached target position - explode
			self.explode();
			return;
		}
		// Update rainbow effect
		self.updateRainbow();
		// Remove if off-screen
		if (self.y > 3000) {
			self.destroy();
			var index = meteoritos.indexOf(self);
			if (index > -1) {
				meteoritos.splice(index, 1);
			}
		}
	};
	self.explode = function () {
		// Generate random color for explosion
		var randomColors = [0xff0000, 0x00ff00, 0x0000ff, 0xffff00, 0xff00ff, 0x00ffff, 0xff8000, 0x8000ff, 0x80ff00, 0xff0080];
		var explosionColor = randomColors[Math.floor(Math.random() * randomColors.length)];
		// Create explosion effect
		var explosion = game.addChild(LK.getAsset('explosion_fuego', {
			anchorX: 0.5,
			anchorY: 0.5,
			x: self.x,
			y: self.y,
			width: 400,
			height: 400
		}));
		explosion.tint = explosionColor;
		explosion.alpha = 0.9;
		// Animate massive explosion with enormous scale
		tween(explosion, {
			scaleX: 40.0,
			scaleY: 40.0,
			alpha: 0
		}, {
			duration: 2500,
			easing: tween.easeOut,
			onFinish: function onFinish() {
				explosion.destroy();
			}
		});
		// Create massive particle explosion
		for (var i = 0; i < 64; i++) {
			var angle = i / 64 * Math.PI * 2;
			var distance = 1600 + Math.random() * 2400;
			var particleEndX = self.x + Math.cos(angle) * distance;
			var particleEndY = self.y + Math.sin(angle) * distance;
			// Generate random color for each particle
			var particleColor = randomColors[Math.floor(Math.random() * randomColors.length)];
			var particle = game.addChild(LK.getAsset('explosion_fuego', {
				anchorX: 0.5,
				anchorY: 0.5,
				x: self.x,
				y: self.y,
				width: 240 + Math.random() * 360,
				height: 240 + Math.random() * 360
			}));
			particle.tint = particleColor;
			particle.alpha = 0.9;
			tween(particle, {
				x: particleEndX,
				y: particleEndY,
				alpha: 0,
				scaleX: 0.05,
				scaleY: 0.05
			}, {
				duration: 2000 + Math.random() * 1000,
				easing: tween.easeOut,
				onFinish: function onFinish() {
					particle.destroy();
				}
			});
		}
		// Hide apocalyptic notes and reset counter when meteorite explodes (before explosion starts)
		ocultar_notas_apocalitica();
		// Deal massive damage to all enemies on the map
		for (var e = enemies.length - 1; e >= 0; e--) {
			var enemy = enemies[e];
			enemy.takeDamage(1000000000000000000); // Deal 1 quintillion damage to guarantee destruction
		}
		// Show message
		showCombinationMessage('¡METEORITO ELEMENTAL - DEVASTACIÓN TOTAL!');
		// Flash screen effect with longer duration for massive impact
		LK.effects.flashScreen(explosionColor, 2000);
		// Clear element list first, then call function to create new random meteorite combination
		elementList = [];
		// Play the meteorite melody instantly when exploding
		playMelodySequenceWithIntervals(['fire', 'water', 'earth', 'wind', 'light'], [0, 200, 200, 200, 200]);
		crea_combinacion_meteorito();
		// Remove meteorite
		self.destroy();
		var index = meteoritos.indexOf(self);
		if (index > -1) {
			meteoritos.splice(index, 1);
		}
	};
	return self;
});
var Nube = Container.expand(function () {
	var self = Container.call(this);
	// Create cloud with random uniform scale to maintain proportions
	var uniformScale = 0.5 + Math.random() * 1.5; // Random scale between 50% and 200%
	var cloudGraphics = self.attachAsset('shape', {
		anchorX: 0.5,
		anchorY: 0.5,
		scaleX: uniformScale,
		scaleY: uniformScale,
		alpha: 0.4 + Math.random() * 0.5 // Random opacity between 40% and 90%
	});
	// Set cloud to white/light gray color
	cloudGraphics.tint = 0xF0F0F0;
	// Random cloud speed (slower clouds for depth) - will be adjusted by height layer
	self.speed = 0.5 + Math.random() * 1.0; // Speed between 0.5 and 1.5
	// Adjust speed based on scale to simulate depth (smaller clouds move slower)
	self.baseSpeed = self.speed;
	// Store initial Y for floating animation
	self.initialY = 0; // Will be set when cloud is positioned
	// Method to start floating animation after positioning
	self.startFloating = function () {
		if (self.initialY === 0) {
			self.initialY = self.y; // Store the manually set position
		}
		var floatAmount = 20 + Math.random() * 30;
		var floatDuration = 3000 + Math.random() * 2000;
		tween(self, {
			y: self.initialY + floatAmount
		}, {
			duration: floatDuration,
			yoyo: true,
			repeat: -1,
			easing: tween.easeInOut
		});
	};
	self.update = function () {
		// Adjust speed based on scale for depth effect (smaller = slower, further away)
		self.speed = self.baseSpeed * (self.scaleX * 0.7 + 0.3); // Scale speed between 30% and 100%
		// Move cloud to the right
		self.x += self.speed;
		// Remove clouds that have moved off-screen to the right
		if (self.x > 4000 + cloudGraphics.width) {
			self.destroy();
			var index = clouds.indexOf(self);
			if (index > -1) {
				clouds.splice(index, 1);
			}
		}
	};
	return self;
});
var Warrior = Container.expand(function (element, tier) {
	var self = Container.call(this);
	var assetName = element + 'Warrior_nivel_' + tier;
	var warriorGraphics = self.attachAsset(assetName, {
		anchorX: 0.5,
		anchorY: 0.5,
		width: 288,
		height: 288
	});
	self.element = element;
	self.tier = tier;
	// Base stats - same as enemies
	var baseDamage = 1;
	var baseHealth = 5;
	// Set elemental-specific stats based on tier
	if (element === 'fire') {
		if (tier === 1) {
			self.maxHealth = 5;
			self.damage = 6;
			self.speed = 2.2;
			self.attackCooldown = 100;
		} else if (tier === 2) {
			self.maxHealth = 10;
			self.damage = 6;
			self.speed = 2.4;
			self.attackCooldown = 50;
		} else if (tier === 3) {
			self.maxHealth = 15;
			self.damage = 18;
			self.speed = 2.6;
			self.attackCooldown = 100;
			self.burnDuration = 3000; // 3 seconds
			self.burnDamage = 6;
			self.canBurn = true;
		} else if (tier === 4) {
			self.maxHealth = 20;
			self.damage = 24;
			self.speed = 2.8;
			self.attackCooldown = 60;
			self.canAreaDamage = true;
			self.areaRange = 400;
			self.burnDuration = 5000; // 5 seconds
			self.burnDamage = 8;
			self.canBurn = true;
		} else if (tier === 5) {
			self.maxHealth = 25;
			self.damage = 50;
			self.speed = 3.0;
			self.attackCooldown = 60;
			self.canActivateFireMode = true;
			self.fireModeActive = false;
		}
	} else if (element === 'water') {
		if (tier === 1) {
			self.maxHealth = 5;
			self.damage = 1;
			self.speed = 1.8;
			self.attackCooldown = 120;
		} else if (tier === 2) {
			self.maxHealth = 10;
			self.damage = 2;
			self.speed = 2.0;
			self.attackCooldown = 120;
			self.selfHealRate = 2; // Heals 2 HP per second
			self.selfHealTimer = 0;
		} else if (tier === 3) {
			self.maxHealth = 15;
			self.damage = 4;
			self.speed = 2.2;
			self.attackCooldown = 120;
			self.selfHealRate = 3.5; // Heals 3.5 HP per second
			self.selfHealTimer = 0;
			self.auraRange = 500;
			self.auraDamageBonus = 4;
			self.explosionTimer = 0;
			self.explosionInterval = 120; // Every 2 seconds
		} else if (tier === 4) {
			self.maxHealth = 20;
			self.damage = 6;
			self.speed = 2.4;
			self.attackCooldown = 120;
			self.selfHealRate = 4; // Heals 4 HP per second
			self.selfHealTimer = 0;
			self.selfHealRate = 5; // Heals 5 HP per second
			self.selfHealTimer = 0;
			self.auraRange = 800;
			self.auraDamageBonus = 10;
			self.explosionTimer = 0;
			self.explosionInterval = 120; // Every 2 seconds
		} else if (tier === 5) {
			self.maxHealth = 25;
			self.damage = 8;
			self.speed = 2.5;
			self.attackCooldown = 120;
			self.selfHealRate = 5; // Heals 5 HP per second
			self.selfHealTimer = 0;
			self.waveTimer = 0;
			self.waveInterval = 300; // Every 5 seconds
		}
		self.canHeal = true;
		self.healCooldown = 0;
		self.isRanged = true;
		self.projectiles = [];
	} else if (element === 'earth') {
		if (tier === 1) {
			self.maxHealth = 20;
			self.damage = 1;
			self.speed = 1.8;
			self.attackCooldown = 120;
		} else if (tier === 2) {
			self.maxHealth = 40;
			self.damage = 4;
			self.speed = 1.8;
			self.attackCooldown = 120;
		} else if (tier === 3) {
			self.maxHealth = 50;
			self.damage = 6;
			self.speed = 1.8;
			self.attackCooldown = 120;
			self.canCreateWalls = true;
			self.wallHealth = 100;
			self.distancia_recorrida = Math.random() * 1000; // Random start between 0-1000
		} else if (tier === 4) {
			self.maxHealth = 80;
			self.damage = 8;
			self.speed = 1.8;
			self.attackCooldown = 120;
			self.canCreateWalls = true;
			self.wallHealth = 200;
			self.damageImmunity = 10; // Immune to damage <= 10
			self.distancia_recorrida = Math.random() * 1000; // Random start between 0-1000
		} else if (tier === 5) {
			self.maxHealth = 100;
			self.damage = 10;
			self.speed = 1.8;
			self.attackCooldown = 120;
			self.canDragEnemies = true;
			self.canSelfDestruct = true;
			self.damageImmunity = 20; // Immune to damage <= 20
			self.distancia_recorrida = Math.random() * 1000; // Random start between 0-1000
		}
	} else if (element === 'light') {
		self.maxHealth = baseHealth;
		self.damage = baseDamage;
		self.speed = 2.5;
		self.isRanged = true;
		self.canAreaDamage = true;
		self.projectiles = [];
	} else if (element === 'wind') {
		if (tier === 1) {
			self.maxHealth = 5;
			self.damage = 1;
			self.speed = 2;
			self.attackCooldown = 60;
		} else if (tier === 2) {
			self.maxHealth = 10;
			self.damage = 2;
			self.speed = 2.4;
			self.attackCooldown = 60;
			self.goldenStatueChance = 0.2; // 20% chance
		} else if (tier === 3) {
			self.maxHealth = 15;
			self.damage = 4;
			self.speed = 2.8;
			self.attackCooldown = 60;
			self.sleepParticleSystem = true;
			self.sleepDuration = 5000; // 5 seconds
		} else if (tier === 4) {
			self.maxHealth = 20;
			self.damage = 8;
			self.speed = 3.2;
			self.attackCooldown = 60;
			self.emeraldSlaveChance = 0.2; // 20% chance
			self.sleepDuration = 10000; // 10 seconds
		} else if (tier === 5) {
			self.maxHealth = 25;
			self.damage = 15;
			self.speed = 3.6;
			self.attackCooldown = 60;
			self.tornadoAttack = true;
		} else {
			self.maxHealth = baseHealth;
			self.damage = baseDamage;
			self.speed = 2.8;
		}
		self.isFlying = true;
		self.isRanged = true;
		self.projectiles = [];
	} else {
		// Default stats for any other element
		self.maxHealth = baseHealth;
		self.damage = baseDamage;
		self.speed = 2;
	}
	self.health = self.maxHealth;
	self.aumento_velocidad = 0;
	// Attack cooldown will be set by elemental stats above
	if (!self.attackCooldown) {
		self.attackCooldown = 0; // Default fallback
	}
	self.baseCooldown = self.attackCooldown || 60; // Store base cooldown for resets
	self.target = null;
	self.isBeingDestroyed = false; // Flag to prevent multiple destruction attempts
	self.activar_movimiento = true; // Boolean to control if warrior can move
	// Physics properties
	self.velocityY = 0;
	self.onGround = false;
	self.gravity = 0.5;
	// Beat effect properties
	self.baseY = 0;
	self.beatEffectTimer = 0;
	// Set warrior size based on tier level - using scale multipliers for visible differences
	var tierScale = 1.0; // Base scale for tier 1
	if (tier === 1) {
		tierScale = 1.0; // Tier 1: normal size (288px)
	} else if (tier === 2) {
		tierScale = 1.17; // Tier 2: 17% bigger (338px)
	} else if (tier === 3) {
		tierScale = 1.35; // Tier 3: 35% bigger (388px)
	} else if (tier === 4) {
		tierScale = 1.52; // Tier 4: 52% bigger (438px)
	} else if (tier === 5) {
		tierScale = 1.69; // Tier 5: 69% bigger (488px)
	}
	// Store the tier scale for later reference
	self.tierScale = tierScale;
	// Apply tier-based scaling immediately and permanently
	warriorGraphics.scaleX = tierScale;
	warriorGraphics.scaleY = tierScale;
	// Apply a simple bounce effect that preserves the tier scale
	var bounceScale = tierScale * 1.1;
	tween(warriorGraphics, {
		scaleX: bounceScale,
		scaleY: bounceScale
	}, {
		duration: 200,
		easing: tween.easeOut,
		onFinish: function onFinish() {
			// Ensure we return to the exact tier scale, not a reference that might change
			tween(warriorGraphics, {
				scaleX: self.tierScale,
				scaleY: self.tierScale
			}, {
				duration: 200,
				easing: tween.easeInOut
			});
		}
	});
	// Health bar
	var healthBar = LK.getAsset('warriorHealthBar', {
		width: 120,
		height: 16
	});
	healthBar.anchor.set(0.5, 0.5);
	healthBar.y = -100;
	self.addChild(healthBar);
	self.healthBar = healthBar;
	// Stats text below warrior
	var statsText = new Text2('', {
		size: 48,
		fill: 0xFFFFFF,
		font: "'GillSans-Bold',Impact,'Arial Black',Tahoma"
	});
	statsText.anchor.set(0.5, 0.5);
	statsText.y = 120; // Position below the warrior
	self.addChild(statsText);
	self.statsText = statsText;
	// Function to update stats display
	self.updateStatsDisplay = function () {
		var attackSpeed = self.baseCooldown || 60;
		var range = 600;
		if (self.isRanged) {
			if (self.element === 'wind') {
				if (self.tier === 2) {
					range = 700;
				} else if (self.tier === 3) {
					range = 800;
				} else if (self.tier === 4) {
					range = 900;
				} else if (self.tier === 5) {
					range = 1200;
				}
			}
		} else {
			range = 250;
		}
		var totalSpeed = self.speed + (self.aumento_velocidad || 0);
		var auraInfo = '';
		if (self.waterAuraCount && self.waterAuraCount > 0) {
			var speedReduction = self.waterAuraCount * 10;
			auraInfo = ' [Aura:' + speedReduction + '%]';
		}
		// Add distance counter for earth warriors tier 3+
		var distanceInfo = '';
		if (self.element === 'earth' && self.tier >= 3 && self.distancia_recorrida !== undefined) {
			distanceInfo = ' [Dist:' + Math.round(self.distancia_recorrida) + ']';
		}
		var statsString = self.health + '-' + self.damage + '-' + totalSpeed + '-' + range + '-' + attackSpeed + auraInfo + distanceInfo;
		self.statsText.setText(statsString);
	};
	// Initialize stats display
	self.updateStatsDisplay();
	self.update = function () {
		// Set base Y position for beat effect
		if (self.baseY === 0) {
			if (self.isFlying) {
				self.baseY = 1800; // Flying height
			} else {
				self.baseY = 2186; // Ground level
			}
		}
		// Apply beat effect if active
		if (self.beatEffectTimer > 0) {
			self.beatEffectTimer--;
			// Get current audio level and calculate rotation strength based on sensitivity difference
			var audioLevel = getGameMusicLevel();
			var sensitivityDifference = Math.max(0, audioLevel - musicBeatThreshold);
			if (sensitivityDifference > 0) {
				var rotationAmount = Math.sin((120 - self.beatEffectTimer) * 0.3) * sensitivityDifference * 0.785;
				warriorGraphics.rotation = rotationAmount;
			} else {
				warriorGraphics.rotation = 0; // No rotation when no difference
			}
		} else {
			warriorGraphics.rotation = 0; // Reset rotation when effect ends
			// Apply gravity only to non-flying units
			if (!self.isFlying && !self.onGround) {
				self.velocityY += self.gravity;
				self.y += self.velocityY;
			}
			// Ground collision for non-flying units
			var groundY = 2186;
			if (!self.isFlying && self.y >= groundY) {
				self.y = groundY;
				self.baseY = groundY; // Update base position
				self.velocityY = 0;
				self.onGround = true;
			} else if (!self.isFlying) {
				self.onGround = false;
			}
			// Flying units hover at a specific height
			if (self.isFlying) {
				self.y = 1800; // Fly above ground level
				self.baseY = 1800; // Update base position
			}
		}
		// Move towards enemy tower only if movement is enabled
		if (!self.target && self.activar_movimiento) {
			var totalSpeed = self.speed + (self.aumento_velocidad || 0);
			var previousX = self.x; // Store previous position for distance calculation
			self.x += totalSpeed;
			// Track distance for earth warriors tier 3+
			if (self.element === 'earth' && self.tier >= 3 && self.distancia_recorrida !== undefined) {
				// Add 1 per movement unit (remove random offset from movement tracking)
				self.distancia_recorrida += 1;
				// Update stats display in real time to show distance changes
				self.updateStatsDisplay();
			}
		}
		// Attack logic
		if (self.attackCooldown > 0) {
			self.attackCooldown--;
		}
		// Update heal cooldown for water warriors
		if (self.canHeal && self.healCooldown > 0) {
			self.healCooldown--;
		}
		// Water warrior self-healing (tier 2+)
		if (self.element === 'water' && self.tier >= 2 && self.selfHealTimer !== undefined) {
			self.selfHealTimer++;
			if (self.selfHealTimer >= 60) {
				// Every second (60 frames at 60fps)
				if (self.health < self.maxHealth) {
					self.health = Math.min(self.health + self.selfHealRate, self.maxHealth);
					// Self-healing visual effect
					tween(warriorGraphics, {
						tint: 0x00ff00
					}, {
						duration: 300,
						onFinish: function onFinish() {
							tween(warriorGraphics, {
								tint: 0xffffff
							}, {
								duration: 300
							});
						}
					});
					// Add healing particles for tier 2 water warrior self-healing
					if (self.tier === 2) {
						for (var p = 0; p < 6; p++) {
							var particle = game.addChild(LK.getAsset('particulas_curacion', {
								anchorX: 0.5,
								anchorY: 0.5,
								x: self.x + (Math.random() - 0.5) * 80,
								y: self.y + (Math.random() - 0.5) * 80,
								width: 120 + Math.random() * 80,
								height: 120 + Math.random() * 80
							}));
							particle.alpha = 0.8;
							tween(particle, {
								y: self.y - 100 - Math.random() * 50,
								alpha: 0,
								scaleX: 0.2,
								scaleY: 0.2
							}, {
								duration: 800,
								easing: tween.easeOut,
								onFinish: function onFinish() {
									particle.destroy();
								}
							});
						}
					}
				}
				self.selfHealTimer = 0;
			}
		}
		// Water warrior aura effects (tier 3+)
		if (self.element === 'water' && self.tier >= 3 && self.auraRange !== undefined) {
			// Apply aura damage bonus and attack speed reduction to nearby allies
			for (var j = 0; j < warriors.length; j++) {
				var ally = warriors[j];
				if (ally !== self && ally.element !== 'water') {
					var allyDistance = Math.sqrt(Math.pow(self.x - ally.x, 2) + Math.pow(self.y - ally.y, 2));
					if (allyDistance < self.auraRange) {
						// Count number of water tier 3+ warriors affecting this ally
						var waterAuraCount = 0;
						for (var k = 0; k < warriors.length; k++) {
							var waterWarrior = warriors[k];
							if (waterWarrior.element === 'water' && waterWarrior.tier >= 3) {
								var waterDistance = Math.sqrt(Math.pow(waterWarrior.x - ally.x, 2) + Math.pow(waterWarrior.y - ally.y, 2));
								if (waterDistance < waterWarrior.auraRange) {
									waterAuraCount++;
								}
							}
						}
						// Only apply speed changes if aura count has changed
						var previousAuraCount = ally.waterAuraCount || 0;
						if (waterAuraCount !== previousAuraCount) {
							// Initialize originalBaseCooldown if not set
							if (!ally.originalBaseCooldown) {
								ally.originalBaseCooldown = ally.baseCooldown || 60;
							}
							// Calculate cumulative speed reduction: each aura reduces by 10%
							var speedReduction = waterAuraCount * 10; // 10% per aura
							var finalSpeedMultiplier = Math.max(0.1, (100 - speedReduction) / 100); // Minimum 0.1 (10% attack speed)
							// Apply the speed reduction to original base cooldown (multiply to reduce cooldown = attack faster)
							ally.baseCooldown = Math.floor(ally.originalBaseCooldown * finalSpeedMultiplier);
							ally.waterAuraCount = waterAuraCount;
							ally.auraAffected = waterAuraCount > 0;
							ally.auraDamageBonus = waterAuraCount > 0 ? self.auraDamageBonus : 0;
						} else {
							// Keep existing values without recalculation
							ally.waterAuraCount = waterAuraCount;
							ally.auraAffected = waterAuraCount > 0;
							ally.auraDamageBonus = waterAuraCount > 0 ? self.auraDamageBonus : 0;
						}
						// Create continuous particles for allies under aura effect (without tinting)
						if (waterAuraCount > 0) {
							// Create continuous particles (7.5x larger)
							if (LK.ticks % 30 === 0) {
								// Every 0.5 seconds
								for (var p = 0; p < 3; p++) {
									var particle = game.addChild(LK.getAsset('particulas_delfin', {
										anchorX: 0.5,
										anchorY: 0.5,
										x: ally.x + (Math.random() - 0.5) * 80,
										y: ally.y + (Math.random() - 0.5) * 80,
										width: (30 + Math.random() * 15) * 7.5,
										height: (30 + Math.random() * 15) * 7.5
									}));
									particle.alpha = 0.8;
									particle.tint = 0xff22aa; // More intense pink color for dolphin particles
									tween(particle, {
										y: ally.y - 100 - Math.random() * 40,
										alpha: 0,
										scaleX: 0.2,
										scaleY: 0.2
									}, {
										duration: 800,
										easing: tween.easeOut,
										onFinish: function onFinish() {
											particle.destroy();
										}
									});
								}
							}
						}
						// Visual feedback when aura count changes
						if (previousAuraCount !== waterAuraCount && waterAuraCount > 0) {
							// Blue glow effect when gaining aura
							tween(ally.children[0], {
								tint: 0x00aaff
							}, {
								duration: 300,
								onFinish: function onFinish() {
									tween(ally.children[0], {
										tint: 0xffffff // Back to white instead of pink
									}, {
										duration: 300
									});
								}
							});
							// Create visual particles around affected ally
							for (var p = 0; p < 4; p++) {
								var particle = game.addChild(LK.getAsset('particulas_curacion', {
									anchorX: 0.5,
									anchorY: 0.5,
									x: ally.x + (Math.random() - 0.5) * 60,
									y: ally.y + (Math.random() - 0.5) * 60,
									width: 40 + Math.random() * 20,
									height: 40 + Math.random() * 20
								}));
								particle.alpha = 0.6;
								particle.tint = 0x00aaff; // Blue for speed aura
								tween(particle, {
									y: ally.y - 80 - Math.random() * 30,
									alpha: 0,
									scaleX: 0.3,
									scaleY: 0.3
								}, {
									duration: 600,
									easing: tween.easeOut,
									onFinish: function onFinish() {
										particle.destroy();
									}
								});
							}
						}
					}
				}
			}
		}
		// Water warrior explosion healing (tier 3+)
		if (self.element === 'water' && self.tier >= 3 && self.explosionTimer !== undefined) {
			self.explosionTimer++;
			if (self.explosionTimer >= self.explosionInterval) {
				// Every 2 seconds
				// Create healing explosion at warrior position
				var explosion = game.addChild(LK.getAsset('particulas_curacion', {
					anchorX: 0.5,
					anchorY: 0.5,
					x: self.x,
					y: self.y,
					width: 400,
					height: 400
				}));
				explosion.alpha = 0.7;
				explosion.tint = 0x00aaff;
				// Animate explosion
				tween(explosion, {
					scaleX: 3.0,
					scaleY: 3.0,
					alpha: 0
				}, {
					duration: 600,
					easing: tween.easeOut,
					onFinish: function onFinish() {
						explosion.destroy();
					}
				});
				// Heal all allies within 400 units
				for (var j = 0; j < warriors.length; j++) {
					var ally = warriors[j];
					var healDistance = Math.sqrt(Math.pow(self.x - ally.x, 2) + Math.pow(self.y - ally.y, 2));
					if (healDistance < 400) {
						// Apply aura damage bonus to explosion healing amount
						var finalHealAmount = self.damage + (self.auraDamageBonus || 0);
						ally.health = Math.min(ally.health + finalHealAmount, ally.maxHealth);
						// Healing particles for affected allies
						for (var p = 0; p < 6; p++) {
							var particle = game.addChild(LK.getAsset('particulas_curacion', {
								anchorX: 0.5,
								anchorY: 0.5,
								x: ally.x + (Math.random() - 0.5) * 80,
								y: ally.y + (Math.random() - 0.5) * 80,
								width: 60 + Math.random() * 40,
								height: 60 + Math.random() * 40
							}));
							particle.alpha = 0.8;
							tween(particle, {
								y: ally.y - 100 - Math.random() * 50,
								alpha: 0,
								scaleX: 0.2,
								scaleY: 0.2
							}, {
								duration: 800,
								easing: tween.easeOut,
								onFinish: function onFinish() {
									particle.destroy();
								}
							});
						}
					}
				}
				self.explosionTimer = 0;
			}
		}
		// Water warrior healing wave (tier 5)
		if (self.element === 'water' && self.tier === 5 && self.waveTimer !== undefined) {
			self.waveTimer++;
			if (self.waveTimer >= self.waveInterval) {
				// Every 5 seconds
				// Create healing wave from player tower to end of map
				var wave = game.addChild(LK.getAsset('ola', {
					anchorX: 0.0,
					anchorY: 0.5,
					x: playerTower.x,
					y: playerTower.y - 200,
					width: 800,
					height: 1000
				}));
				wave.tint = 0x00ffff;
				// Store wave damage for collision detection
				wave.finalWaveDamage = self.damage + (self.auraDamageBonus || 0);
				// Track which enemies have been hit by this wave
				wave.hitEnemies = [];
				// Add wave update method for collision detection
				wave.update = function () {
					// Check collision with enemies for damage
					for (var e = 0; e < enemies.length; e++) {
						var enemy = enemies[e];
						// Check if enemy hasn't been hit by this wave yet
						if (wave.hitEnemies.indexOf(enemy) === -1) {
							// Check collision between wave and enemy - use wave center for better detection
							var waveCenterX = wave.x + wave.width * 0.5; // Center of wave
							var waveCenterY = wave.y; // Center Y position
							var waveDistance = Math.sqrt(Math.pow(waveCenterX - enemy.x, 2) + Math.pow(waveCenterY - enemy.y, 2));
							if (waveDistance < 300) {
								// Enemy is hit by wave - mark immediately to prevent multiple hits
								wave.hitEnemies.push(enemy);
								// Deal damage to enemy
								enemy.takeDamage(wave.finalWaveDamage);
								// Create splash effect at impact using salpicadura asset
								var splash = game.addChild(LK.getAsset('salpicadura', {
									anchorX: 0.5,
									anchorY: 0.5,
									x: enemy.x,
									y: enemy.y,
									width: 350,
									height: 350
								}));
								splash.alpha = 0.9;
								splash.tint = 0x00ffff;
								// Animate splash with scale and rotation
								tween(splash, {
									scaleX: 3.0,
									scaleY: 3.0,
									alpha: 0,
									rotation: Math.PI * 0.75
								}, {
									duration: 700,
									easing: tween.easeOut,
									onFinish: function onFinish() {
										splash.destroy();
									}
								});
								// Create additional water splash particles in a circular pattern
								for (var splashIndex = 0; splashIndex < 12; splashIndex++) {
									var angle = splashIndex / 12 * Math.PI * 2;
									var distance = 100 + Math.random() * 80;
									var splashEndX = enemy.x + Math.cos(angle) * distance;
									var splashEndY = enemy.y + Math.sin(angle) * distance;
									var splashParticle = game.addChild(LK.getAsset('salpicadura', {
										anchorX: 0.5,
										anchorY: 0.5,
										x: enemy.x,
										y: enemy.y,
										width: 60 + Math.random() * 40,
										height: 60 + Math.random() * 40
									}));
									splashParticle.alpha = 0.8;
									splashParticle.tint = 0x00ddff;
									// Animate splash particles spreading outward
									tween(splashParticle, {
										x: splashEndX,
										y: splashEndY,
										alpha: 0,
										scaleX: 0.2,
										scaleY: 0.2,
										rotation: Math.random() * Math.PI * 2
									}, {
										duration: 500 + Math.random() * 300,
										easing: tween.easeOut,
										onFinish: function onFinish() {
											splashParticle.destroy();
										}
									});
								}
							}
						}
					}
					// Check collision with warriors for speed boost
					for (var w = 0; w < warriors.length; w++) {
						var warrior = warriors[w];
						// Check if warrior hasn't been hit by this wave yet  
						if (wave.hitEnemies.indexOf(warrior) === -1) {
							// Check collision between wave and warrior - use wave center for better detection
							var waveCenterX = wave.x + wave.width * 0.5; // Center of wave
							var waveDistance = Math.sqrt(Math.pow(waveCenterX - warrior.x, 2) + Math.pow(wave.y - warrior.y, 2));
							if (waveDistance < 300) {
								// Warrior is hit by wave
								wave.hitEnemies.push(warrior);
								// Increase speed only if not already boosted by tier 5 water warrior wave
								if (!warrior.tier5WaveSpeedBoosted) {
									warrior.aumento_velocidad = (warrior.aumento_velocidad || 0) + 2;
									warrior.tier5WaveSpeedBoosted = true;
									// Visual effect for speed boost
									tween(warrior.children[0], {
										tint: 0x00ffff
									}, {
										duration: 500,
										onFinish: function onFinish() {
											tween(warrior.children[0], {
												tint: 0xffffff
											}, {
												duration: 500
											});
										}
									});
									warrior.updateStatsDisplay();
								}
							}
						}
					}
				};
				// Animate wave across the map
				tween(wave, {
					x: 4500,
					// Move to end of map
					scaleX: 2.0
				}, {
					duration: 3000,
					easing: tween.linear,
					onFinish: function onFinish() {
						wave.destroy();
					}
				});
				// Heal all allies to full health immediately
				for (var j = 0; j < warriors.length; j++) {
					warriors[j].health = warriors[j].maxHealth;
				}
				showCombinationMessage('¡TSUNAMI CURATIVO ACTIVADO!');
				self.waveTimer = 0;
			}
		}
		// Water warriors heal nearby allies
		if (self.canHeal && self.healCooldown <= 0) {
			self.healCooldown = 120; // 2 seconds
			// Heal nearby warriors
			for (var j = 0; j < warriors.length; j++) {
				var ally = warriors[j];
				if (ally !== self) {
					var allyDistance = Math.sqrt(Math.pow(self.x - ally.x, 2) + Math.pow(self.y - ally.y, 2));
					if (allyDistance < 600 && ally.health < ally.maxHealth) {
						// Apply aura damage bonus to healing amount
						var finalHealAmount = self.damage + (self.auraDamageBonus || 0);
						ally.health = Math.min(ally.health + finalHealAmount, ally.maxHealth);
						// Healing effect
						tween(ally.children[0], {
							tint: 0x00ff88
						}, {
							duration: 200,
							onFinish: function onFinish() {
								tween(ally.children[0], {
									tint: 0xffffff
								}, {
									duration: 200
								});
							}
						});
						// Create healing particles
						for (var particleIndex = 0; particleIndex < 8; particleIndex++) {
							var particle = game.addChild(LK.getAsset('particulas_curacion', {
								anchorX: 0.5,
								anchorY: 0.5,
								x: ally.x + (Math.random() - 0.5) * 100,
								y: ally.y + (Math.random() - 0.5) * 100,
								width: 140 + Math.random() * 100,
								height: 140 + Math.random() * 100
							}));
							particle.alpha = 0.8;
							// Animate particles upward and fade out
							tween(particle, {
								y: ally.y - 150 - Math.random() * 50,
								x: ally.x + (Math.random() - 0.5) * 200,
								alpha: 0,
								scaleX: 0.3,
								scaleY: 0.3
							}, {
								duration: 800 + Math.random() * 400,
								easing: tween.easeOut,
								onFinish: function onFinish() {
									particle.destroy();
								}
							});
						}
					}
				}
			}
		}
		// Check for enemies to attack and combat engagement
		var inCombat = false;
		var attackRange = 250; // Default melee range
		if (self.isRanged) {
			attackRange = 600; // Default ranged
			if (self.element === 'wind') {
				if (self.tier === 1) {
					attackRange = 600;
				} else if (self.tier === 2) {
					attackRange = 700;
				} else if (self.tier === 3) {
					attackRange = 800;
				} else if (self.tier === 4) {
					attackRange = 900;
				} else if (self.tier === 5) {
					attackRange = 1200;
				}
			}
		}
		// For wind warriors (aerial units), find the closest enemy
		if (self.element === 'wind' && self.isFlying) {
			var closestEnemy = null;
			var closestDistance = Infinity; // Start with infinite distance
			// Find the closest enemy within range
			for (var i = 0; i < enemies.length; i++) {
				var enemy = enemies[i];
				var distance = Math.sqrt(Math.pow(self.x - enemy.x, 2) + Math.pow(self.y - enemy.y, 2));
				if (distance < attackRange && distance < closestDistance) {
					closestEnemy = enemy;
					closestDistance = distance;
				}
			}
			// Attack the closest enemy if found
			if (closestEnemy && self.attackCooldown <= 0) {
				inCombat = true;
				self.attack(closestEnemy);
				// Attack animation - flash blue and scale up while preserving tier scale
				var attackScale = self.tierScale * 1.4;
				tween(warriorGraphics, {
					tint: 0x00ffff,
					scaleX: attackScale,
					scaleY: attackScale
				}, {
					duration: 300,
					onFinish: function onFinish() {
						tween(warriorGraphics, {
							tint: 0xffffff,
							scaleX: self.tierScale,
							scaleY: self.tierScale
						}, {
							duration: 300
						});
					}
				});
			}
		} else {
			// Original logic for all other units
			for (var i = 0; i < enemies.length; i++) {
				var enemy = enemies[i];
				// Use half width for warrior and enemy colliders but keep full height
				var warriorColliderWidth = 288 * 0.5; // Half of warrior width
				var enemyColliderWidth = 280 * 0.5; // Half of enemy width
				var distance = Math.sqrt(Math.pow(self.x - enemy.x, 2) + Math.pow(self.y - enemy.y, 2));
				if (distance < attackRange) {
					// Mark as in combat to stop movement for all ranged units including water warriors
					inCombat = true;
					// Attack logic based on warrior type
					if (self.attackCooldown <= 0) {
						if (self.element === 'water') {
							// Water warriors only do ranged attacks
							if (self.isRanged) {
								self.attack(enemy);
								// Attack animation - flash blue and scale up while preserving tier scale
								var attackScale = self.tierScale * 1.4;
								tween(warriorGraphics, {
									tint: 0x00ffff,
									scaleX: attackScale,
									scaleY: attackScale
								}, {
									duration: 300,
									onFinish: function onFinish() {
										tween(warriorGraphics, {
											tint: 0xffffff,
											scaleX: self.tierScale,
											scaleY: self.tierScale
										}, {
											duration: 300
										});
									}
								});
							}
						} else if (self.isRanged) {
							// Other ranged warriors (light, wind)
							self.attack(enemy);
							// Attack animation - flash blue and scale up while preserving tier scale
							var attackScale = self.tierScale * 1.4;
							tween(warriorGraphics, {
								tint: 0x00ffff,
								scaleX: attackScale,
								scaleY: attackScale
							}, {
								duration: 300,
								onFinish: function onFinish() {
									tween(warriorGraphics, {
										tint: 0xffffff,
										scaleX: self.tierScale,
										scaleY: self.tierScale
									}, {
										duration: 300
									});
								}
							});
						} else {
							// Melee warriors (fire, earth) - attack directly
							self.attack(enemy);
							// Attack animation - flash red for fire warriors and scale up while preserving tier scale
							var attackTint = self.element === 'fire' ? 0xff4400 : 0x8b4513; // Fire red or earth brown
							var attackScale = self.tierScale * 1.4;
							tween(warriorGraphics, {
								tint: attackTint,
								scaleX: attackScale,
								scaleY: attackScale
							}, {
								duration: 300,
								onFinish: function onFinish() {
									tween(warriorGraphics, {
										tint: 0xffffff,
										scaleX: self.tierScale,
										scaleY: self.tierScale
									}, {
										duration: 300
									});
								}
							});
						}
					}
					// Break out of loop for all ranged units except wind warriors to stop movement
					if (self.isRanged && self.element !== 'wind') {
						break;
					} else if (!self.isRanged) {
						break;
					}
				}
			}
		}
		// Check if warrior is at the tower x position - stop movement to focus on tower attack
		var atTowerPosition = Math.abs(self.x - playerTower.x) <= 50;
		// Update projectiles for ranged units
		if (self.isRanged) {
			for (var p = self.projectiles.length - 1; p >= 0; p--) {
				var proj = self.projectiles[p];
				proj.x += proj.speedX;
				proj.y += proj.speedY;
				var projectileDestroyed = false;
				// Water warrior projectiles can heal allies
				if (self.element === 'water') {
					// Check collision with allies first
					for (var w = 0; w < warriors.length; w++) {
						var ally = warriors[w];
						if (ally !== self) {
							// Use half width for ally collider but keep full height
							var allyColliderWidth = 288 * 0.5; // Half of ally width
							var allyDistance = Math.sqrt(Math.pow(proj.x - ally.x, 2) + Math.pow(proj.y - ally.y, 2));
							if (allyDistance < 50) {
								// Hit ally
								if (ally.health < ally.maxHealth) {
									// Heal ally if not at full health (heal amount equals water warrior's damage plus aura bonus)
									var finalHealAmount = self.damage + (self.auraDamageBonus || 0);
									ally.health = Math.min(ally.health + finalHealAmount, ally.maxHealth);
									// Healing effect
									tween(ally.children[0], {
										tint: 0x00ff88
									}, {
										duration: 200,
										onFinish: function onFinish() {
											tween(ally.children[0], {
												tint: 0xffffff
											}, {
												duration: 200
											});
										}
									});
									// Create healing particles
									for (var particleIndex = 0; particleIndex < 8; particleIndex++) {
										var particle = game.addChild(LK.getAsset('particulas_curacion', {
											anchorX: 0.5,
											anchorY: 0.5,
											x: ally.x + (Math.random() - 0.5) * 100,
											y: ally.y + (Math.random() - 0.5) * 100,
											width: 140 + Math.random() * 100,
											height: 140 + Math.random() * 100
										}));
										particle.alpha = 0.8;
										// Animate particles upward and fade out
										tween(particle, {
											y: ally.y - 150 - Math.random() * 50,
											x: ally.x + (Math.random() - 0.5) * 200,
											alpha: 0,
											scaleX: 0.3,
											scaleY: 0.3
										}, {
											duration: 800 + Math.random() * 400,
											easing: tween.easeOut,
											onFinish: function onFinish() {
												particle.destroy();
											}
										});
									}
									proj.destroy();
									self.projectiles.splice(p, 1);
									projectileDestroyed = true;
									break;
								}
								// If ally is at full health, projectile passes through
							}
						}
					}
				}
				// Check collision with enemies only if projectile wasn't destroyed by healing
				if (!projectileDestroyed) {
					for (var e = 0; e < enemies.length; e++) {
						var enemy = enemies[e];
						// Use half width for enemy collider but keep full height
						var enemyColliderWidth = 280 * 0.5; // Half of enemy width
						var projDistance = Math.sqrt(Math.pow(proj.x - enemy.x, 2) + Math.pow(proj.y - enemy.y, 2));
						if (projDistance < 80) {
							// Increased collision radius for better detection
							// Hit enemy
							if (self.canAreaDamage) {
								// Create lightning explosion visual effect at projectile impact point
								var explosion = game.addChild(LK.getAsset('efecto_electricidad', {
									anchorX: 0.5,
									anchorY: 0.5,
									x: proj.x,
									y: proj.y,
									width: 80,
									height: 80
								}));
								explosion.alpha = 0.9;
								// Animate explosion - scale up and fade out
								tween(explosion, {
									scaleX: 3.0,
									scaleY: 3.0,
									alpha: 0
								}, {
									duration: 400,
									easing: tween.easeOut,
									onFinish: function onFinish() {
										explosion.destroy();
									}
								});
								// Create electric particles expanding from explosion center
								for (var particleIndex = 0; particleIndex < 12; particleIndex++) {
									var angle = particleIndex / 12 * Math.PI * 2; // Distribute evenly in circle
									var distance = 150 + Math.random() * 100;
									var particleEndX = proj.x + Math.cos(angle) * distance;
									var particleEndY = proj.y + Math.sin(angle) * distance;
									var electricParticle = game.addChild(LK.getAsset('efecto_electricidad', {
										anchorX: 0.5,
										anchorY: 0.5,
										x: proj.x,
										y: proj.y,
										width: 20 + Math.random() * 20,
										height: 20 + Math.random() * 20
									}));
									electricParticle.alpha = 0.8;
									// Animate particles expanding outward and fading
									tween(electricParticle, {
										x: particleEndX,
										y: particleEndY,
										alpha: 0,
										scaleX: 0.2,
										scaleY: 0.2
									}, {
										duration: 300 + Math.random() * 200,
										easing: tween.easeOut,
										onFinish: function onFinish() {
											electricParticle.destroy();
										}
									});
								}
								// Lightning area damage - increased damage for area effect
								for (var ae = 0; ae < enemies.length; ae++) {
									var areaEnemy = enemies[ae];
									var areaDistance = Math.sqrt(Math.pow(proj.x - areaEnemy.x, 2) + Math.pow(proj.y - areaEnemy.y, 2));
									if (areaDistance < 600) {
										areaEnemy.takeDamage(1); // Set damage to 1 for area effect
									}
								}
							} else {
								// Handle wind warrior special effects
								if (self.element === 'wind') {
									// Apply base damage first
									var finalDamage = self.damage + (self.auraDamageBonus || 0);
									enemy.takeDamage(finalDamage);
									// Tier 2: Golden statue effect
									if (proj.goldenStatueChance && Math.random() < proj.goldenStatueChance) {
										enemy.isGoldenStatue = true;
										enemy.enemigo_oro = true; // Set golden statue variable
										enemy.activar_movimiento = false;
										enemy.canAttack = false;
										// Remove golden statue effect after some time (permanent for now)
									}
									// Wind warrior projectiles only deal damage now - no special effects
									// Tier 5: Tornado attack
									else if (proj.tornadoAttack && proj.attackedEnemies.indexOf(enemy) === -1) {
										proj.attackedEnemies.push(enemy); // Mark enemy as attacked by this projectile
										enemy.inTornado = true;
										enemy.activar_movimiento = false;
										enemy.canAttack = false;
										enemy.tornadoTimer = 0;
										enemy.tornadoDuration = 10000; // 10 seconds
										enemy.children[0].tint = 0x44FF44; // Wind green tint
										// Lift enemy up
										tween(enemy, {
											y: enemy.y - 200
										}, {
											duration: 1000,
											easing: tween.easeOut
										});
										// Apply tornado damage over time (10% max health per second)
										enemy.tornadoDamageInterval = LK.setInterval(function () {
											if (enemy.inTornado) {
												var tornadoDamage = Math.floor(enemy.maxHealth * 0.1);
												enemy.takeDamage(tornadoDamage);
											}
										}, 1000);
										// Remove tornado effect after duration
										LK.setTimeout(function () {
											enemy.inTornado = false;
											enemy.activar_movimiento = true;
											enemy.canAttack = true;
											enemy.children[0].tint = 0xFFFFFF;
											LK.clearInterval(enemy.tornadoDamageInterval);
											// Drop enemy back down
											tween(enemy, {
												y: 2186
											}, {
												duration: 1000,
												easing: tween.easeIn
											});
										}, enemy.tornadoDuration);
									}
								} else if (self.element === 'water') {
									enemy.takeDamage(self.damage);
								} else {
									// Apply aura damage bonus if affected by water warrior aura
									var finalDamage = self.damage + (self.auraDamageBonus || 0);
									enemy.takeDamage(finalDamage);
								}
							}
							proj.destroy();
							self.projectiles.splice(p, 1);
							projectileDestroyed = true;
							break;
						}
					}
				}
				// Remove projectiles that go off screen only if not already destroyed
				if (!projectileDestroyed && (proj.x > 4500 || proj.x < -500 || proj.y > 3500 || proj.y < -500)) {
					proj.destroy();
					self.projectiles.splice(p, 1);
				}
			}
		}
		// Set activar_movimiento based on combat state and element type
		if (inCombat && self.element !== 'wind') {
			// Stop movement for all elements except wind when in combat range
			self.activar_movimiento = false;
		} else {
			// Allow movement when not in combat, and always allow movement for wind warriors
			self.activar_movimiento = true;
		}
		// Special case: Wind warriors always maintain movement, even during combat
		if (self.element === 'wind') {
			self.activar_movimiento = true;
		}
		// Apply movement based on activar_movimiento flag
		// Wind warriors ignore tower position blocking and maintain movement
		if (!self.activar_movimiento || atTowerPosition && self.element !== 'wind') {
			self.speed = 0;
		} else {
			// Resume normal movement with base speed
			var baseSpeed = 2;
			if (self.element === 'fire') {
				baseSpeed = 2.2;
			} else if (self.element === 'water') {
				baseSpeed = 1.8;
			} else if (self.element === 'earth') {
				baseSpeed = 1.5;
			} else if (self.element === 'light') {
				baseSpeed = 2.5;
			} else if (self.element === 'wind') {
				baseSpeed = 2.8;
			}
			self.speed = baseSpeed;
		}
		// Earth warrior wall creation (tier 3+)
		if (self.element === 'earth' && self.tier >= 3 && self.canCreateWalls && self.distancia_recorrida !== undefined) {
			// Check if we've traveled 1100 units to create a wall
			if (self.distancia_recorrida >= 1100) {
				// Determine wall asset and size based on tier
				var wallAsset, wallWidth, wallHeight;
				if (self.tier === 3) {
					wallAsset = 'muro_tierra';
					wallWidth = 360; // Normal size
					wallHeight = 393;
				} else if (self.tier === 4) {
					wallAsset = 'muro_tierra_nivel_2';
					wallWidth = 540; // 50% bigger
					wallHeight = 590;
				} else if (self.tier === 5) {
					wallAsset = 'muro_tierra_nivel_3';
					wallWidth = 720; // 100% bigger
					wallHeight = 786;
				}
				// Create wall positioned like a warrior unit
				var wall = game.addChild(LK.getAsset(wallAsset, {
					anchorX: 0.5,
					anchorY: 0.5,
					x: self.x,
					y: 2186,
					// Ground level - centered like warriors
					width: wallWidth,
					height: wallHeight
				}));
				wall.alpha = 0.75; // 75% opacity
				wall.isWall = true;
				wall.health = self.wallHealth;
				wall.maxHealth = self.wallHealth;
				wall.activar_movimiento = false; // Cannot move like warriors
				wall.canAttack = false; // Cannot attack like warriors
				// Create green health bar for wall (50% larger and visible)
				var wallHealthBar = LK.getAsset('warriorHealthBar', {
					width: 180,
					height: 24
				});
				wallHealthBar.anchor.set(0.5, 0.5);
				wallHealthBar.x = 0; // Centered above wall
				wallHealthBar.y = -200; // Move much higher above wall
				wallHealthBar.alpha = 1.0; // Ensure full visibility
				// Add health bar directly to game instead of wall to ensure it's on top
				game.addChild(wallHealthBar);
				wall.healthBar = wallHealthBar;
				// Update health bar position when wall position changes
				wall.updateHealthBarPosition = function () {
					if (this.healthBar) {
						this.healthBar.x = this.x;
						this.healthBar.y = this.y - 200;
					}
				};
				wall.updateHealthBarPosition();
				wall.takeDamage = function (damage) {
					this.health -= damage;
					var healthPercent = this.health / this.maxHealth;
					if (this.healthBar) {
						this.healthBar.scaleX = healthPercent;
					}
					// Health bar color is already green from warriorHealthBar asset - no tinting needed
					// Flash wall red when taking damage
					tween(this.children[0], {
						tint: 0xff0000
					}, {
						duration: 200,
						onFinish: function () {
							tween(this.children[0], {
								tint: 0xffffff
							}, {
								duration: 200
							});
						}.bind(this)
					});
					// Create debris particles when wall takes damage
					var particleCount = damage * 8; // Scale particles with damage amount
					for (var debrisIndex = 0; debrisIndex < particleCount; debrisIndex++) {
						// 180-degree spread pattern (forward facing)
						var angle = (debrisIndex / particleCount - 0.5) * Math.PI; // Spread from -90 to +90 degrees
						var force = (150 + Math.random() * 200) * 3; // Random force
						var velocityX = Math.cos(angle) * force;
						var velocityY = Math.sin(angle) * force;
						var debrisParticle = game.addChild(LK.getAsset('escombros_torre_enemiga', {
							anchorX: 0.5,
							anchorY: 0.5,
							x: this.x,
							y: this.y - 100,
							width: (40 + Math.random() * 30) * 3,
							height: (40 + Math.random() * 30) * 3,
							rotation: Math.random() * Math.PI * 2
						}));
						debrisParticle.alpha = 0.9;
						debrisParticle.tint = 0x8B4513; // Brown color for earth debris
						// Add physics properties
						debrisParticle.velocityX = velocityX * 0.015; // Scale down for smooth movement
						debrisParticle.velocityY = velocityY * 0.015;
						debrisParticle.gravity = 0.6; // Gravity effect
						// Animate debris particles with physics
						tween(debrisParticle, {
							y: this.y + 150 + debrisParticle.velocityY * 80,
							x: this.x + debrisParticle.velocityX * 80,
							alpha: 0,
							rotation: debrisParticle.rotation + Math.PI * 3,
							scaleX: 0.1,
							scaleY: 0.1
						}, {
							duration: 1500 + Math.random() * 800,
							easing: tween.easeOut,
							onFinish: function onFinish() {
								debrisParticle.destroy();
							}
						});
					}
					if (this.health <= 0) {
						// Clean up health bar before destroying wall
						if (this.healthBar) {
							this.healthBar.destroy();
							this.healthBar = null;
						}
						this.destroy();
					}
				};
				// Wall update function - acts like a stationary warrior
				wall.update = function () {
					// Update health bar position to stay above wall
					this.updateHealthBarPosition();
					// Check collision with enemies using warrior-like collision detection
					for (var e = 0; e < enemies.length; e++) {
						var enemy = enemies[e];
						// Use similar collision detection as warriors but with wall dimensions
						var wallColliderWidth = 240 * 0.5; // Half of wall width like warriors
						var enemyColliderWidth = 280 * 0.5; // Half of enemy width
						var distance = Math.sqrt(Math.pow(this.x - enemy.x, 2) + Math.pow(this.y - enemy.y, 2));
						if (distance < 200) {
							// Enemy in combat range with wall
							if (enemy.attackCooldown <= 0) {
								this.takeDamage(enemy.damage);
								enemy.attackCooldown = 80;
							}
							// Stop enemy movement when in combat with wall
							enemy.speed = 0;
							enemy.inCombat = true;
						} else if (distance > 350) {
							// Enemy far from wall, can resume movement
							if (!enemy.inCombat) {
								enemy.speed = 1.5;
							}
						}
					}
				};
				// Reset distance counter to 0 after creating wall
				self.distancia_recorrida = 0;
				self.updateStatsDisplay(); // Update display to show reset counter
			}
		}
		// Wind warrior tier 3 spore generation
		if (self.element === 'wind' && self.tier === 3) {
			// Generate spores every 30 frames (0.5 seconds)
			if (LK.ticks % 30 === 0) {
				// Create 2-3 spores
				var numSpores = 2 + Math.floor(Math.random() * 2);
				for (var sporeIndex = 0; sporeIndex < numSpores; sporeIndex++) {
					var espora = new Espora(self);
					game.addChild(espora);
					esporas.push(espora);
				}
			}
		}
		// Wind warrior tier 5 enemy dragging and tower destruction
		if (self.element === 'earth' && self.tier === 5) {
			// Drag enemies backward every second
			if (LK.ticks % 60 === 0) {
				// Every second
				for (var e = 0; e < enemies.length; e++) {
					var enemy = enemies[e];
					var distance = Math.sqrt(Math.pow(self.x - enemy.x, 2) + Math.pow(self.y - enemy.y, 2));
					if (distance < 600) {
						// Push enemy forward 300 units smoothly (away from our towers)
						var targetX = enemy.x + 300;
						tween(enemy, {
							x: targetX
						}, {
							duration: 1000,
							// 1 second
							easing: tween.easeOut
						});
						// Deal damage each second of dragging
						enemy.takeDamage(self.damage);
						// Visual effect for dragging
						tween(enemy.children[0], {
							tint: 0x8b4513
						}, {
							duration: 200,
							onFinish: function onFinish() {
								tween(enemy.children[0], {
									tint: 0xffffff
								}, {
									duration: 200
								});
							}
						});
					}
				}
			}
			// Check if close to enemy tower for self-destruction
			var towerDistance = Math.sqrt(Math.pow(self.x - enemyTower.x, 2) + Math.pow(self.y - enemyTower.y, 2));
			if (towerDistance < 800 && self.canSelfDestruct) {
				// Self-destruct and become wall with 250 health
				showCombinationMessage('¡GUERRERO TIERRA SE SACRIFICA POR LA DEFENSA!');
				// Create mega wall positioned like a warrior unit
				var megaWall = game.addChild(LK.getAsset('muro_tierra_nivel_3', {
					anchorX: 0.5,
					anchorY: 0.5,
					x: self.x,
					y: 2186,
					width: 720,
					// 100% larger wall (level 3)
					height: 786
				}));
				megaWall.alpha = 0.75; // 75% opacity
				megaWall.isWall = true;
				megaWall.health = 2000;
				megaWall.maxHealth = 2000;
				megaWall.activar_movimiento = false; // Cannot move like warriors
				megaWall.canAttack = false; // Cannot attack like warriors
				// Create green health bar for mega wall (50% larger and visible)
				var megaWallHealthBar = LK.getAsset('warriorHealthBar', {
					width: 216,
					height: 32
				});
				megaWallHealthBar.anchor.set(0.5, 0.5);
				megaWallHealthBar.x = 0; // Centered above mega wall
				megaWallHealthBar.y = -280; // Move much higher above mega wall
				megaWallHealthBar.alpha = 1.0; // Ensure full visibility
				// Add health bar directly to game instead of mega wall to ensure it's on top
				game.addChild(megaWallHealthBar);
				megaWall.healthBar = megaWallHealthBar;
				// Update health bar position when mega wall position changes
				megaWall.updateHealthBarPosition = function () {
					if (this.healthBar) {
						this.healthBar.x = this.x;
						this.healthBar.y = this.y - 280;
					}
				};
				megaWall.updateHealthBarPosition();
				megaWall.takeDamage = function (damage) {
					this.health -= damage;
					var healthPercent = this.health / this.maxHealth;
					if (this.healthBar) {
						this.healthBar.scaleX = healthPercent;
					}
					// Health bar color is already green from warriorHealthBar asset - no tinting needed
					// Flash mega wall red when taking damage
					tween(this.children[0], {
						tint: 0xff0000
					}, {
						duration: 200,
						onFinish: function () {
							tween(this.children[0], {
								tint: 0xffffff
							}, {
								duration: 200
							});
						}.bind(this)
					});
					// Create debris particles when mega wall takes damage
					var particleCount = damage * 12; // More particles for mega wall
					for (var debrisIndex = 0; debrisIndex < particleCount; debrisIndex++) {
						// 180-degree spread pattern (forward facing)
						var angle = (debrisIndex / particleCount - 0.5) * Math.PI; // Spread from -90 to +90 degrees
						var force = (200 + Math.random() * 250) * 4; // Stronger force for mega wall
						var velocityX = Math.cos(angle) * force;
						var velocityY = Math.sin(angle) * force;
						var debrisParticle = game.addChild(LK.getAsset('escombros_torre_enemiga', {
							anchorX: 0.5,
							anchorY: 0.5,
							x: this.x,
							y: this.y - 150,
							width: (50 + Math.random() * 40) * 4,
							height: (50 + Math.random() * 40) * 4,
							rotation: Math.random() * Math.PI * 2
						}));
						debrisParticle.alpha = 0.9;
						debrisParticle.tint = 0x8B4513; // Brown color for earth debris
						// Add physics properties
						debrisParticle.velocityX = velocityX * 0.02; // Scale down for smooth movement
						debrisParticle.velocityY = velocityY * 0.02;
						debrisParticle.gravity = 0.8; // Gravity effect
						// Animate debris particles with physics
						tween(debrisParticle, {
							y: this.y + 200 + debrisParticle.velocityY * 100,
							x: this.x + debrisParticle.velocityX * 100,
							alpha: 0,
							rotation: debrisParticle.rotation + Math.PI * 4,
							scaleX: 0.1,
							scaleY: 0.1
						}, {
							duration: 2000 + Math.random() * 1000,
							easing: tween.easeOut,
							onFinish: function onFinish() {
								debrisParticle.destroy();
							}
						});
					}
					if (this.health <= 0) {
						// Clean up health bar before destroying mega wall
						if (this.healthBar) {
							this.healthBar.destroy();
							this.healthBar = null;
						}
						this.destroy();
					}
				};
				// Mega wall update function - acts like a stationary warrior
				megaWall.update = function () {
					// Update health bar position to stay above mega wall
					this.updateHealthBarPosition();
					// Check collision with enemies using warrior-like collision detection
					for (var e = 0; e < enemies.length; e++) {
						var enemy = enemies[e];
						// Use similar collision detection as warriors but with mega wall dimensions
						var megaWallColliderWidth = 360 * 0.5; // Half of mega wall width like warriors
						var enemyColliderWidth = 280 * 0.5; // Half of enemy width
						var distance = Math.sqrt(Math.pow(this.x - enemy.x, 2) + Math.pow(this.y - enemy.y, 2));
						if (distance < 250) {
							// Enemy in combat range with mega wall
							if (enemy.attackCooldown <= 0) {
								this.takeDamage(enemy.damage);
								enemy.attackCooldown = 80;
							}
							// Stop enemy movement when in combat with mega wall
							enemy.speed = 0;
							enemy.inCombat = true;
						} else if (distance > 450) {
							// Enemy far from mega wall, can resume movement
							if (!enemy.inCombat) {
								enemy.speed = 1.5;
							}
						}
					}
				};
				// Remove warrior from game
				self.isBeingDestroyed = true;
				var index = warriors.indexOf(self);
				if (index > -1) {
					warriors.splice(index, 1);
				}
				self.destroy();
				return; // Exit update after self-destruction
			}
		}
		// Check collision with enemy tower - use separate x and y collision detection for flying units
		var towerColliderRadius = 700; // Fixed collider size, not scaled with tower
		var warriorColliderWidth = 288 * 0.5; // Half of warrior width
		var warriorColliderHeight = 288; // Full warrior height
		var towerDistance = Math.sqrt(Math.pow(self.x - enemyTower.x, 2) + Math.pow(self.y - enemyTower.y, 2));
		var xDistance = Math.abs(self.x - enemyTower.x);
		var yDistance = Math.abs(self.y - enemyTower.y);
		// Debug collision for wind warriors
		if (self.element === 'wind') {
			collisionDebugText.setText('Wind Warrior - XDist: ' + Math.round(xDistance) + ' YDist: ' + Math.round(yDistance) + ' Pos: (' + Math.round(self.x) + ',' + Math.round(self.y) + ')');
		}
		// Use different collision detection for flying units vs ground units
		var collisionDetected = false;
		if (self.isFlying) {
			// For flying units, use x-distance only (ignore y difference)
			collisionDetected = xDistance < towerColliderRadius;
		} else {
			// For ground units, use traditional distance-based collision
			collisionDetected = towerDistance < towerColliderRadius;
		}
		if (collisionDetected && !self.isBeingDestroyed) {
			// Debug when collision happens
			if (self.element === 'wind') {
				collisionDebugText.setText('WIND COLLISION! XDist: ' + Math.round(xDistance) + ' Damage: ' + self.damage);
			}
			// Deal damage to tower first - always attack regardless of cooldown when touching tower
			self.attackTower();
			// Mark as being destroyed to prevent multiple collision detections
			self.isBeingDestroyed = true;
			// Remove from warriors array immediately
			var index = warriors.indexOf(self);
			if (index > -1) {
				warriors.splice(index, 1);
			}
			// Warrior self-destructs when touching the tower - immediate destruction
			self.destroy();
			return; // Exit update to prevent further execution after destruction
		}
		// Check projectile collision with enemy tower for ranged units - tower is invulnerable to projectiles
		if (self.isRanged) {
			for (var p = self.projectiles.length - 1; p >= 0; p--) {
				var proj = self.projectiles[p];
				var projTowerDistance = Math.sqrt(Math.pow(proj.x - enemyTower.x, 2) + Math.pow(proj.y - enemyTower.y, 2));
				if (projTowerDistance < 700) {
					// Fixed collider radius
					// Projectile hit the tower but tower is invulnerable - just destroy projectile
					proj.destroy();
					self.projectiles.splice(p, 1);
				}
			}
		}
		// Check if warrior is off-screen and destroy
		if (self.x < -500 || self.x > 4500 || self.y > 3500) {
			self.destroy();
			var index = warriors.indexOf(self);
			if (index > -1) {
				warriors.splice(index, 1);
			}
			return; // Exit update to prevent further execution
		}
		// Update health bar
		var healthPercent = self.health / self.maxHealth;
		self.healthBar.scaleX = healthPercent;
		self.healthBar.tint = healthPercent > 0.5 ? 0x00ff00 : healthPercent > 0.25 ? 0xffff00 : 0xff0000;
	};
	self.attack = function (target) {
		self.attackCooldown = self.baseCooldown || 60; // Use tier-based cooldown
		if (target === enemyTower) {
			self.attackTower();
		} else if (self.isRanged) {
			// Special mini-wave attack for tier 4 water warriors
			if (self.element === 'water' && self.tier === 4) {
				// Create mini-wave that travels 800 units with larger size (same as tier 5)
				var miniWave = game.addChild(LK.getAsset('ola', {
					anchorX: 0.0,
					anchorY: 0.5,
					x: self.x - 400,
					y: self.y,
					width: 800,
					height: 500
				}));
				miniWave.tint = 0x00ffff;
				miniWave.alpha = 0.8;
				// Store wave damage for collision detection
				var finalWaveDamage = self.damage + (self.auraDamageBonus || 0);
				miniWave.finalWaveDamage = finalWaveDamage;
				// Track which enemies and allies have been hit by this wave
				miniWave.hitEnemies = [];
				miniWave.healedAllies = [];
				// Add wave update method for collision detection
				miniWave.update = function () {
					// Check collision with enemies - only once per enemy per wave
					for (var e = 0; e < enemies.length; e++) {
						var enemy = enemies[e];
						// Check if enemy hasn't been hit by this specific wave yet
						if (miniWave.hitEnemies.indexOf(enemy) === -1) {
							// Check collision between wave and enemy - use thin collider positioned at center of image
							var waveCenterX = miniWave.x + miniWave.width * 0.5; // Center of wave image
							var waveCenterY = miniWave.y; // Center Y position
							var waveDistance = Math.sqrt(Math.pow(waveCenterX - enemy.x, 2) + Math.pow(waveCenterY - enemy.y, 2));
							if (waveDistance < 50) {
								// Thin collision radius of 50 units for precise detection
								// Enemy is hit by wave - mark immediately to prevent multiple hits
								miniWave.hitEnemies.push(enemy);
								// Always deal damage when hit by mini-wave - use base damage only (6)
								enemy.takeDamage(6); // Fixed damage of 6 for mini-waves 
								// Set miniola_colision to true and update enemy stats
								enemy.miniola_colision = true;
								enemy.updateStatsDisplay();
								// Set immunity timer for 1 second using setTimeout
								LK.setTimeout(function () {
									enemy.miniola_colision = false;
									enemy.updateStatsDisplay();
								}, 1000);
								// Create splash effect at impact using salpicadura asset
								var splash = game.addChild(LK.getAsset('salpicadura', {
									anchorX: 0.5,
									anchorY: 0.5,
									x: enemy.x,
									y: enemy.y,
									width: 300,
									height: 300
								}));
								splash.alpha = 0.9;
								splash.tint = 0x00aaff;
								// Animate splash with scale and fade
								tween(splash, {
									scaleX: 2.5,
									scaleY: 2.5,
									alpha: 0,
									rotation: Math.PI * 0.5
								}, {
									duration: 600,
									easing: tween.easeOut,
									onFinish: function onFinish() {
										splash.destroy();
									}
								});
								// Create additional water droplet particles around the splash
								for (var dropletIndex = 0; dropletIndex < 8; dropletIndex++) {
									var angle = dropletIndex / 8 * Math.PI * 2;
									var distance = 80 + Math.random() * 60;
									var dropletEndX = enemy.x + Math.cos(angle) * distance;
									var dropletEndY = enemy.y + Math.sin(angle) * distance;
									var droplet = game.addChild(LK.getAsset('salpicadura', {
										anchorX: 0.5,
										anchorY: 0.5,
										x: enemy.x,
										y: enemy.y,
										width: 40 + Math.random() * 30,
										height: 40 + Math.random() * 30
									}));
									droplet.alpha = 0.7;
									droplet.tint = 0x1e90ff;
									// Animate droplets spreading outward and fading
									tween(droplet, {
										x: dropletEndX,
										y: dropletEndY,
										alpha: 0,
										scaleX: 0.3,
										scaleY: 0.3,
										rotation: Math.random() * Math.PI * 2
									}, {
										duration: 400 + Math.random() * 200,
										easing: tween.easeOut,
										onFinish: function onFinish() {
											droplet.destroy();
										}
									});
								}
							}
						}
					}
					// Check collision with allies for healing
					for (var w = 0; w < warriors.length; w++) {
						var ally = warriors[w];
						// Check if ally hasn't been healed by this wave yet
						if (miniWave.healedAllies.indexOf(ally) === -1) {
							// Check collision between wave and ally - use thin collider positioned at center of image
							var waveCenterX = miniWave.x + miniWave.width * 0.5; // Center of wave image
							var waveCenterY = miniWave.y; // Center Y position
							var allyDistance = Math.sqrt(Math.pow(waveCenterX - ally.x, 2) + Math.pow(waveCenterY - ally.y, 2));
							if (allyDistance < 50) {
								// Thin collision radius of 50 units for precise detection
								// Ally is healed by wave - mark immediately to prevent multiple heals
								miniWave.healedAllies.push(ally);
								// Heal ally if not at full health
								if (ally.health < ally.maxHealth) {
									// Heal for exactly 10 (6 base + 4 bonus)
									ally.health = Math.min(ally.health + 10, ally.maxHealth);
									// Healing effect
									tween(ally.children[0], {
										tint: 0x00ff88
									}, {
										duration: 200,
										onFinish: function onFinish() {
											tween(ally.children[0], {
												tint: 0xffffff
											}, {
												duration: 200
											});
										}
									});
									// Create healing particles
									for (var particleIndex = 0; particleIndex < 6; particleIndex++) {
										var particle = game.addChild(LK.getAsset('particulas_curacion', {
											anchorX: 0.5,
											anchorY: 0.5,
											x: ally.x + (Math.random() - 0.5) * 80,
											y: ally.y + (Math.random() - 0.5) * 80,
											width: 80 + Math.random() * 40,
											height: 80 + Math.random() * 40
										}));
										particle.alpha = 0.8;
										tween(particle, {
											y: ally.y - 100 - Math.random() * 50,
											alpha: 0,
											scaleX: 0.2,
											scaleY: 0.2
										}, {
											duration: 800,
											easing: tween.easeOut,
											onFinish: function onFinish() {
												particle.destroy();
											}
										});
									}
								}
							}
						}
					}
				};
				// Animate wave across 800 units distance
				tween(miniWave, {
					x: self.x + 800,
					scaleX: 1.5
				}, {
					duration: 1500,
					easing: tween.linear,
					onFinish: function onFinish() {
						miniWave.destroy();
					}
				});
				self.projectiles.push(miniWave);
				// Play water projectile sound
				playRandomProjectileSound(self.element);
				return; // Exit after creating mini-wave
			} else {
				// Regular projectiles for other ranged units
				var projectileSize = 120; // Larger projectiles for better visibility (doubled from 60)
				var projectileAsset = self.element === 'light' ? 'proyectil_electricidad' : 'projectile';
				var projectile = game.addChild(LK.getAsset(projectileAsset, {
					anchorX: 0.5,
					anchorY: 0.5,
					x: self.x,
					y: self.y - 20,
					// Start slightly above warrior
					width: projectileSize,
					height: projectileSize
				}));
				// Calculate direction to target
				var dx = target.x - self.x;
				var dy = target.y - self.y;
				var distance = Math.sqrt(dx * dx + dy * dy);
				var speed = 10; // Increased speed for better gameplay
				projectile.speedX = dx / distance * speed;
				projectile.speedY = dy / distance * speed;
				// Set projectile appearance based on element
				if (self.element === 'light') {
					projectile.alpha = 0.9; // Slightly transparent for glow effect
					// Add pulsing effect for lightning
					tween(projectile, {
						scaleX: 1.3,
						scaleY: 1.3
					}, {
						duration: 300,
						yoyo: true,
						repeat: -1
					});
				} else if (self.element === 'wind') {
					projectile.tint = 0x44ff44; // Green for wind
					projectile.alpha = 0.8;
					// Add spinning effect for wind
					tween(projectile, {
						rotation: Math.PI * 2
					}, {
						duration: 500,
						repeat: -1
					});
					// Add tier-specific projectile properties
					if (self.tier === 2) {
						projectile.goldenStatueChance = self.goldenStatueChance;
					} else if (self.tier === 3) {
						projectile.sleepParticleSystem = true;
						projectile.sleepDuration = self.sleepDuration;
					} else if (self.tier === 4) {
						projectile.emeraldSlaveChance = self.emeraldSlaveChance;
						projectile.sleepDuration = self.sleepDuration;
					} else if (self.tier === 5) {
						projectile.tornadoAttack = true;
						projectile.attackedEnemies = []; // Track which enemies this projectile has attacked
					}
				} else if (self.element === 'water') {
					projectile.tint = 0x1e90ff; // Sea blue for water (DodgerBlue)
					projectile.alpha = 0.85;
					// Add wobbling effect for water
					tween(projectile, {
						scaleX: 1.2,
						scaleY: 0.8
					}, {
						duration: 200,
						yoyo: true,
						repeat: -1
					});
				}
				self.projectiles.push(projectile);
				// Auto-destroy projectile after 5 seconds to prevent map clutter
				tween(projectile, {
					alpha: projectile.alpha // Dummy property to track time
				}, {
					duration: 5000,
					// 5 seconds
					onFinish: function onFinish() {
						// Find and remove projectile from array
						var index = self.projectiles.indexOf(projectile);
						if (index > -1) {
							self.projectiles.splice(index, 1);
						}
						// Destroy the projectile
						projectile.destroy();
					}
				});
				// Play element-specific projectile sound
				playRandomProjectileSound(self.element);
				return; // Exit after creating projectile to prevent melee sound
			}
		} else {
			// Melee combat - deal damage directly to target
			var finalDamage = self.damage + (self.auraDamageBonus || 0);
			target.takeDamage(finalDamage);
			// Fire warriors with burn ability (tier 3+)
			if (self.element === 'fire' && self.canBurn && target.takeBurnDamage) {
				target.takeBurnDamage(0, self.burnDuration, self.burnDamage); // No initial damage since we already dealt damage above
			}
			// Fire tier 4 warriors have area damage with fire explosion visual effect
			if (self.element === 'fire' && self.canAreaDamage) {
				// Create fire explosion visual effect at target position
				var explosion = game.addChild(LK.getAsset('explosion_fuego', {
					anchorX: 0.5,
					anchorY: 0.5,
					x: target.x,
					y: target.y,
					width: 120,
					height: 120
				}));
				explosion.alpha = 0.9;
				explosion.tint = 0xff4400; // Fire color
				// Animate explosion - scale up and fade out
				tween(explosion, {
					scaleX: 5.0,
					scaleY: 5.0,
					alpha: 0
				}, {
					duration: 800,
					easing: tween.easeOut,
					onFinish: function onFinish() {
						explosion.destroy();
					}
				});
				// Create fire particles expanding from explosion center
				for (var particleIndex = 0; particleIndex < 16; particleIndex++) {
					var angle = particleIndex / 16 * Math.PI * 2; // Distribute evenly in circle
					var distance = 200 + Math.random() * 150;
					var particleEndX = target.x + Math.cos(angle) * distance;
					var particleEndY = target.y + Math.sin(angle) * distance;
					var fireParticle = game.addChild(LK.getAsset('explosion_fuego', {
						anchorX: 0.5,
						anchorY: 0.5,
						x: target.x,
						y: target.y,
						width: 30 + Math.random() * 30,
						height: 30 + Math.random() * 30
					}));
					fireParticle.alpha = 0.7;
					fireParticle.tint = 0xff6600; // Orange fire color
					// Animate particles expanding outward and fading
					tween(fireParticle, {
						x: particleEndX,
						y: particleEndY,
						alpha: 0,
						scaleX: 0.2,
						scaleY: 0.2
					}, {
						duration: 600 + Math.random() * 400,
						easing: tween.easeOut,
						onFinish: function onFinish() {
							fireParticle.destroy();
						}
					});
				}
				for (var ae = 0; ae < enemies.length; ae++) {
					var areaEnemy = enemies[ae];
					var areaDistance = Math.sqrt(Math.pow(target.x - areaEnemy.x, 2) + Math.pow(target.y - areaEnemy.y, 2));
					if (areaDistance < 400 && areaEnemy !== target) {
						if (areaEnemy.takeBurnDamage) {
							areaEnemy.takeBurnDamage(self.damage * 0.5, self.burnDuration, self.burnDamage);
						}
					}
				}
			}
			// Play sword attack sound for melee attacks
			sonidoEspadas();
		}
	};
	self.attackTower = function () {
		self.attackCooldown = 60;
		enemyTowerHealth -= self.damage;
		// Play random tower damage sound
		var towerSounds = ['sonido_torre_1', 'sonido_torre_2', 'sonido_torre_3', 'sonido_torre_4'];
		var randomIndex = Math.floor(Math.random() * towerSounds.length);
		var sound = LK.getSound(towerSounds[randomIndex]);
		sound.volume = soundValue;
		sound.play();
		// Create escombros particles when enemy tower takes damage - quantity based on damage
		var particleCount = self.damage * 12; // Multiply particle count by damage
		for (var escombrosIndex = 0; escombrosIndex < particleCount; escombrosIndex++) {
			// 360-degree explosion pattern
			var angle = escombrosIndex / particleCount * Math.PI * 2; // Distribute evenly in 360 degrees
			var force = (200 + Math.random() * 300) * 4; // Quadruple the force
			var velocityX = Math.cos(angle) * force;
			var velocityY = Math.sin(angle) * force;
			var escombrosParticle = game.addChild(LK.getAsset('escombros_torre_enemiga', {
				anchorX: 0.5,
				anchorY: 0.5,
				x: enemyTower.x,
				y: enemyTower.y - 800,
				width: (60 + Math.random() * 40) * 5,
				height: (60 + Math.random() * 40) * 5,
				rotation: Math.random() * Math.PI * 2
			}));
			escombrosParticle.alpha = 0.9;
			escombrosParticle.tint = 0x696969; // Dark gray color for enemy debris
			// Add gravity and physics properties
			escombrosParticle.velocityX = velocityX * 0.02; // Scale down for smooth movement
			escombrosParticle.velocityY = velocityY * 0.02;
			escombrosParticle.gravity = 0.8; // Gravity effect
			// Animate escombros particles with physics
			tween(escombrosParticle, {
				y: enemyTower.y + 200 + escombrosParticle.velocityY * 100,
				x: enemyTower.x + escombrosParticle.velocityX * 100,
				alpha: 0,
				rotation: escombrosParticle.rotation + Math.PI * 4,
				scaleX: 0.1,
				scaleY: 0.1
			}, {
				duration: 2000 + Math.random() * 1000,
				easing: tween.easeOut,
				onFinish: function onFinish() {
					escombrosParticle.destroy();
				}
			});
		}
		if (enemyTowerHealth <= 0) {
			LK.showYouWin();
		}
		updateTowerHealthBars();
	};
	self.takeDamage = function (damage) {
		// Earth warrior tier 4+ damage immunity
		if (self.element === 'earth' && self.tier >= 4 && self.damageImmunity && damage <= self.damageImmunity) {
			// Immune to damage - show visual feedback
			tween(self.children[0], {
				tint: 0x8b4513
			}, {
				duration: 200,
				onFinish: function onFinish() {
					tween(self.children[0], {
						tint: 0xffffff
					}, {
						duration: 200
					});
				}
			});
			return; // No damage taken
		}
		self.health -= damage;
		// Update stats display to show current health
		self.updateStatsDisplay();
		if (self.health <= 0) {
			// Mark as being destroyed to prevent multiple destruction attempts
			self.isBeingDestroyed = true;
			// Death animation - fade out and scale down from current tier scale
			var deathScale = self.tierScale * 0.1;
			tween(warriorGraphics, {
				alpha: 0,
				scaleX: deathScale,
				scaleY: deathScale,
				rotation: -Math.PI * 2
			}, {
				duration: 600,
				easing: tween.easeOut,
				onFinish: function onFinish() {
					self.destroy();
				}
			});
			// Only remove from warriors array if not already removed by collision detection
			if (!self.isBeingDestroyed || self.isBeingDestroyed) {
				var index = warriors.indexOf(self);
				if (index > -1) {
					warriors.splice(index, 1);
				}
			}
		}
	};
	return self;
});

/**** 
* Initialize Game
****/ 
var game = new LK.Game({
	backgroundColor: 0x2c3e50,
	width: 3840,
	height: 1080
});

/**** 
* Game Code
****/ 
function _typeof3(o) {
	"@babel/helpers - typeof";
	return _typeof3 = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) {
		return typeof o;
	} : function (o) {
		return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
	}, _typeof3(o);
}
function _typeof2(o) {
	"@babel/helpers - typeof";
	return _typeof2 = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) {
		return typeof o;
	} : function (o) {
		return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
	}, _typeof2(o);
}
function _typeof(o) {
	"@babel/helpers - typeof";
	return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) {
		return typeof o;
	} : function (o) {
		return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
	}, _typeof(o);
}
var warriors = [];
var enemies = [];
var meteoritos = [];
var esporas = [];
var dormido = true; // Global sleep state variable - start active
var globalFireModeActive = false;
var fireModeTimer = 0;
var playerTowerHealth = 30;
var enemyTowerHealth = 10;
var enemySpawnTimer = 0;
var isDragging = false;
var lastMouseX = 0;
var cameraX = 0;
var maxCameraX = 1792; // 3840 - 2048 = max scroll distance
var currentMana = 5;
var maxMana = 5;
var manaRegenTimer = 0;
var miniola_colision = false;
// Combination system variables
var currentCombination = [];
var combinationTimer = 0;
var combinationCooldown = 0;
var maxCombinationLength = 10;
var combinationWindowTime = 60; // 1 second at 60fps
var combinationResetTime = 60; // 1 second at 60fps
var temporaryNoteCounter = 0; // Helper counter for tracking notes (1-5)
// Apocalipsis system variables
var tiempoDeApocalipsis = 0; // Timer for tracking idle time without note presses (10 seconds = 600 frames)
var apocalipsisThreshold = 600; // 10 seconds at 60fps
// Element list system for meteorite invocation
var elementList = [];
var maxElementList = 5;
// Timing interval tracking variables
var noteTimingIntervals = []; // Store time intervals between note presses
var lastNoteTime = 0; // Timestamp of last note press
var isFirstNote = true; // Track if this is the first note in a sequence
// Touch position tracking variables
var initialTouchX = 0;
var initialTouchY = 0;
var currentTouchX = 0;
var currentTouchY = 0;
// Music beat detection variables
var musicBeatThreshold = 0; // Default sensitivity threshold set to 0 - will be controlled by sensitivity button
var lastBeatTime = 0;
var beatCooldown = 15; // Reduced cooldown for more frequent detections (0.25 seconds at 60fps)
// UI Elements
var scoreText = new Text2('Score: 0', {
	size: 40,
	fill: 0xFFFFFF
});
scoreText.anchor.set(0, 0);
scoreText.x = 120;
scoreText.y = 50;
LK.gui.topLeft.addChild(scoreText);
// Create mana display
var manaText = new Text2('Mana: 5/5', {
	size: 40,
	fill: 0x00FFFF
});
manaText.anchor.set(0, 0);
manaText.x = 1100;
manaText.y = 100;
LK.gui.topLeft.addChild(manaText);
// Create mana orbs visual display
var manaOrbs = [];
for (var i = 0; i < maxMana; i++) {
	var orb = LK.getAsset('manaOrbShape', {
		width: 40,
		height: 40
	});
	orb.anchor.set(0.5, 0.5);
	orb.x = 1100 + i * 50;
	orb.y = 160;
	LK.gui.topLeft.addChild(orb);
	manaOrbs.push(orb);
}
// Settings panel state
var settingsPanelVisible = false;
var settingsBars = [];
// Settings values (0.0 to 1.0 range)
var musicValue = 0.8;
var soundValue = 0.8;
var sensitivityValue = 0.5;
// Create settings button below mana bar
var settingsButton = LK.getAsset('settingsIcon', {
	width: 120,
	height: 120
});
settingsButton.anchor.set(0.5, 0.5);
settingsButton.x = 1200; // Move slightly to the right
settingsButton.y = 250; // Move down a bit more
settingsButton.alpha = 0.8;
LK.gui.topLeft.addChild(settingsButton);
// Create music volume text input
var musicVolumeInput = new Text2('Volumen Música: 80', {
	size: 30,
	fill: 0xFFFFFF
});
musicVolumeInput.anchor.set(0.5, 0.5);
musicVolumeInput.x = 1200;
musicVolumeInput.y = 380;
musicVolumeInput.alpha = 0;
LK.gui.topLeft.addChild(musicVolumeInput);
// Store all settings elements
settingsBars = [musicVolumeInput];
// Function to update music volume
function updateMusicVolume(value) {
	// Parse and validate the input value
	var volumeNumber = parseInt(value);
	if (isNaN(volumeNumber)) {
		volumeNumber = 80;
	}
	volumeNumber = Math.max(0, Math.min(100, volumeNumber));
	musicValue = volumeNumber / 100;
	musicVolumeInput.setText('Volumen Música: ' + volumeNumber);
	// Apply music volume changes immediately
	LK.stopMusic();
	LK.playMusic('Music', {
		volume: musicValue
	});
}
// Music volume input interaction
musicVolumeInput.down = function (x, y, obj) {
	// Simple interaction for now - could be enhanced with actual text input
	var currentVolume = Math.round(musicValue * 100);
	var newVolume = (currentVolume + 10) % 110; // Cycle through 0-100 by 10s
	updateMusicVolume(newVolume);
};
settingsButton.down = function (x, y, obj) {
	// Play settings click sound with centralized control like music - stop and restart with current volume
	LK.getSound('settings_click').stop(); // Stop any currently playing instance
	var settingsSound = LK.getSound('settings_click');
	settingsSound.volume = soundValue * 0.7; // Apply current soundValue with 70% modifier
	settingsSound.play();
	// Visual feedback with bounce effect
	tween(settingsButton, {
		scaleX: 0.85,
		scaleY: 0.85,
		alpha: 0.6,
		rotation: Math.PI * 0.1
	}, {
		duration: 150,
		easing: tween.easeOut,
		onFinish: function onFinish() {
			tween(settingsButton, {
				scaleX: 1.05,
				scaleY: 1.05,
				alpha: 0.9,
				rotation: 0
			}, {
				duration: 150,
				easing: tween.bounceOut,
				onFinish: function onFinish() {
					tween(settingsButton, {
						scaleX: 1.0,
						scaleY: 1.0,
						alpha: 0.8
					}, {
						duration: 100
					});
				}
			});
		}
	});
	// Toggle settings panel with staggered animations
	if (settingsPanelVisible) {
		// Hide settings panel with staggered fade out
		settingsPanelVisible = false;
		for (var i = 0; i < settingsBars.length; i++) {
			var delay = i * 30; // Stagger each element by 30ms
			tween(settingsBars[i], {
				alpha: 0,
				y: settingsBars[i].y - 20,
				scaleX: 0.8,
				scaleY: 0.8
			}, {
				duration: 300,
				delay: delay,
				easing: tween.easeInOut
			});
		}
	} else {
		// Show settings panel with bouncy entrance
		settingsPanelVisible = true;
		for (var i = 0; i < settingsBars.length; i++) {
			var delay = i * 40; // Stagger each element by 40ms
			var targetY = settingsBars[i].y;
			settingsBars[i].y = targetY - 30;
			settingsBars[i].scaleX = 0.6;
			settingsBars[i].scaleY = 0.6;
			tween(settingsBars[i], {
				alpha: 1,
				y: targetY,
				scaleX: 1.0,
				scaleY: 1.0
			}, {
				duration: 400,
				delay: delay,
				easing: tween.elasticOut
			});
		}
	}
};
// Create collision debug text in center of game
var collisionDebugText = new Text2('Collision Debug', {
	size: 60,
	fill: 0xFFFF00
});
collisionDebugText.anchor.set(0.5, 0.5);
collisionDebugText.x = 1024; // Center of screen width (2048/2)
collisionDebugText.y = 1366; // Center of screen height (2732/2)
game.addChild(collisionDebugText);
// Create audio debug text to show real-time values
var audioDebugText = new Text2('Audio: 0.00 | Threshold: 0.15 | Diff: 0.00', {
	size: 40,
	fill: 0x00FFFF
});
audioDebugText.anchor.set(0.5, 0.5);
audioDebugText.x = 1024; // Center of screen width
audioDebugText.y = 1200; // Above collision debug text
game.addChild(audioDebugText);
// Create touch position debug text
var touchDebugText = new Text2('Touch Info: Initial(0,0) Current(0,0)', {
	size: 40,
	fill: 0xFF00FF
});
touchDebugText.anchor.set(0.5, 0.5);
touchDebugText.x = 1024; // Center of screen width
touchDebugText.y = 1500; // Below collision debug text
game.addChild(touchDebugText);
// Create combination message text
var combinationMessageText = new Text2('', {
	size: 60,
	fill: 0xFFFF00
});
combinationMessageText.anchor.set(0.5, 0.5);
combinationMessageText.x = 1024; // Center of screen width
combinationMessageText.y = 800; // Above other debug texts
combinationMessageText.alpha = 0;
game.addChild(combinationMessageText);
// Create temporary note counter info text
var tempCounterInfoText = new Text2('Notas presionadas: 0', {
	size: 40,
	fill: 0x00FF00
});
tempCounterInfoText.anchor.set(0.5, 0.5);
tempCounterInfoText.x = 1024; // Center of screen width
tempCounterInfoText.y = 600; // Above combination message text
game.addChild(tempCounterInfoText);
// Create element list display text
var elementListText = new Text2('Lista de Elementos: []', {
	size: 45,
	fill: 0xFFD700
});
elementListText.anchor.set(0.5, 0.5);
elementListText.x = 1024; // Center of screen width
elementListText.y = 400; // Above temp counter text
game.addChild(elementListText);
// Create timing intervals info text
var timingIntervalsText = new Text2('Intervalos: []', {
	size: 35,
	fill: 0xFFAA00
});
timingIntervalsText.anchor.set(0.5, 0.5);
timingIntervalsText.x = 1024; // Center of screen width
timingIntervalsText.y = 500; // Above temp counter text
game.addChild(timingIntervalsText);
// Create sky background - always behind everything
var skyBackground = game.addChildAt(LK.getAsset('cielo', {
	anchorX: 0.0,
	anchorY: 0.0,
	x: 0,
	y: 0,
	width: 3840,
	height: 2732
}), 0); // Add at index 0 to be behind everything
// Create tiled ground floor
var groundTiles = [];
var tileSize = 592.704; // Size of each ground tile (increased by 5% more)
var groundY = 2732; // Position at bottom of screen
var groundHeight = 728.6; // Extend height to fill bottom gap (tileSize + 136 pixels)
var numTiles = Math.ceil(3840 / tileSize) + 2; // Cover full width plus extra for seamless tiling
for (var i = 0; i < numTiles; i++) {
	var groundTile = game.addChild(LK.getAsset('ground', {
		anchorX: 0.0,
		anchorY: 1.0,
		x: i * tileSize,
		y: groundY,
		width: tileSize,
		height: groundHeight
	}));
	groundTiles.push(groundTile);
}
// Create red overlay for fire mode (initially hidden)
var fireOverlay = game.addChild(LK.getAsset('healthBar', {
	anchorX: 0.0,
	anchorY: 0.0,
	x: 0,
	y: 0,
	width: 3840,
	height: 2732
}));
fireOverlay.tint = 0xff0000; // Red color
fireOverlay.alpha = 0; // Initially hidden
// Create towers (horizontal layout)
var playerTower = game.addChild(LK.getAsset('playerTower', {
	anchorX: 0.5,
	anchorY: 1.0,
	x: 250,
	y: 2559,
	width: 1200,
	height: 1728
}));
var enemyTower = game.addChild(LK.getAsset('enemyTower', {
	anchorX: 0.5,
	anchorY: 1.0,
	x: 3590,
	y: 2559,
	width: 1200,
	height: 1728
}));
// Tower health bars
var playerTowerHealthBar = LK.getAsset('playerTowerHealthBar', {
	width: 1200,
	height: 160
});
playerTowerHealthBar.anchor.set(0.5, 0.5);
playerTowerHealthBar.x = playerTower.x;
playerTowerHealthBar.y = playerTower.y - 1840;
game.addChild(playerTowerHealthBar);
var enemyTowerHealthBar = LK.getAsset('enemyTowerHealthBar', {
	width: 1200,
	height: 160
});
enemyTowerHealthBar.anchor.set(0.5, 0.5);
enemyTowerHealthBar.x = enemyTower.x;
enemyTowerHealthBar.y = enemyTower.y - 1840;
game.addChild(enemyTowerHealthBar);
// Create elemental notes (horizontal layout at top left) - show all elements
var elements = ['fire', 'water', 'earth', 'wind', 'light'];
var notes = [];
for (var i = 0; i < elements.length; i++) {
	var note = new ElementalNote(elements[i], 0, 0);
	LK.gui.topLeft.addChild(note);
	// Make buttons smaller
	note.scaleX = 0.4;
	note.scaleY = 0.4;
	// Position buttons horizontally in upper left with proper spacing (moved 50% right total)
	note.x = 234 + i * 140; // Start at x:234 (moved from 180), space buttons 140 pixels apart
	note.y = 120; // Fixed y position in upper area
	notes.push(note);
}
// Create five apocalyptic note images below the elemental notes
var casillas = [];
for (var i = 0; i < 5; i++) {
	var casilla = LK.getAsset('nota_apocalitica', {
		width: 60,
		height: 60,
		anchorX: 0.5,
		anchorY: 0.5
	});
	casilla.x = 409 + i * 70; // Moved left 25 units (from 434 to 409)
	casilla.y = 220; // Moved down 20 units (from 200 to 220)
	LK.gui.topLeft.addChild(casilla);
	casillas.push(casilla);
}
// Create camera control buttons
var leftButton = LK.getAsset('leftCameraButton', {
	width: 100,
	height: 100
});
leftButton.anchor.set(0.5, 0.5);
leftButton.alpha = 0.5; // 50% transparency
LK.gui.left.addChild(leftButton);
var leftButtonText = new Text2('<', {
	size: 60,
	fill: 0xffffff
});
leftButtonText.anchor.set(0.5, 0.5);
leftButton.addChild(leftButtonText);
var rightButton = LK.getAsset('rightCameraButton', {
	width: 100,
	height: 100
});
rightButton.anchor.set(0.5, 0.5);
rightButton.alpha = 0.5; // 50% transparency
LK.gui.right.addChild(rightButton);
var rightButtonText = new Text2('>', {
	size: 60,
	fill: 0xffffff
});
rightButtonText.anchor.set(0.5, 0.5);
rightButton.addChild(rightButtonText);
function notePressed(element) {
	// Reset apocalypse timer when any note is pressed
	tiempoDeApocalipsis = 0;
	// If this is the start of a new combination, clear previous timing data
	if (currentCombination.length === 0) {
		noteTimingIntervals = [];
		isFirstNote = true;
		lastNoteTime = 0;
	}
	// Record timing for interval tracking
	var currentTime = Date.now();
	if (isFirstNote) {
		// First note - record time and initialize with 0 interval
		lastNoteTime = currentTime;
		isFirstNote = false;
		noteTimingIntervals = [0]; // Initialize with 0 for first note
	} else {
		// Calculate interval since last note
		var interval = currentTime - lastNoteTime;
		noteTimingIntervals.push(interval);
		lastNoteTime = currentTime;
	}
	// Update timing intervals display
	var intervalsDisplay = noteTimingIntervals.length > 0 ? 'Intervalos: [' + noteTimingIntervals.map(function (interval) {
		return Math.round(interval) + 'ms';
	}).join(', ') + ']' : 'Intervalos: []';
	timingIntervalsText.setText(intervalsDisplay);
	// Element list is now managed separately by crea_combinacion_meteorito function
	// Do not add pressed notes to element list
	// Increment temporary counter
	temporaryNoteCounter++;
	// Add element to current combination
	addToCombination(element);
	// Check if current combination exactly matches the required meteorite sequence
	if (currentCombination.length === 5) {
		var hasMatchingCombination = true;
		for (var i = 0; i < 5; i++) {
			if (currentCombination[i] !== elementList[i]) {
				hasMatchingCombination = false;
				break;
			}
		}
		if (hasMatchingCombination) {
			// Current combination matches the required meteorite notes - invoke meteorite and set mana to zero
			currentMana = 0;
			updateManaDisplay();
			// Summon meteorite
			summonMeteorito();
			showCombinationMessage('¡METEORITO INVOCADO CON 5 ELEMENTOS!');
			// Reset combination
			resetCombination();
			temporaryNoteCounter = 0;
			enableNoteButtons();
			return;
		}
	}
	// Disable buttons if temporary counter equals or exceeds available mana
	if (temporaryNoteCounter >= currentMana) {
		disableAllNoteButtons();
	}
	// Only process immediately if we've reached max combination length
	if (currentCombination.length >= maxCombinationLength) {
		processCombination();
	}
}
function spawnEnemy() {
	var enemy = new Enemy();
	enemy.x = enemyTower.x - 300;
	enemy.y = 2186; // Spawn on ground level
	enemy.onGround = true; // Start on ground
	game.addChild(enemy);
	enemies.push(enemy);
}
function summonMeteorito() {
	var meteorito = new Meteorito();
	meteorito.x = 0; // Start at x=0
	meteorito.y = 0; // Start at y=0
	game.addChild(meteorito);
	meteoritos.push(meteorito);
}
function updateTowerHealthBars() {
	var playerHealthPercent = Math.max(0, playerTowerHealth / 30);
	var enemyHealthPercent = Math.max(0, enemyTowerHealth / 10);
	playerTowerHealthBar.scaleX = playerHealthPercent;
	enemyTowerHealthBar.scaleX = enemyHealthPercent;
	// Scale towers based on health - minimum scale of 0.3 (30%), maximum 1.0 (100%)
	var playerTowerScale = 0.3 + playerHealthPercent * 0.7; // 0.3 to 1.0 range
	var enemyTowerScale = 0.3 + enemyHealthPercent * 0.7; // 0.3 to 1.0 range
	// Apply scaling to towers
	tween.stop(playerTower, {
		scaleX: true,
		scaleY: true
	});
	tween.stop(enemyTower, {
		scaleX: true,
		scaleY: true
	});
	tween(playerTower, {
		scaleX: playerTowerScale,
		scaleY: playerTowerScale
	}, {
		duration: 500,
		easing: tween.easeInOut
	});
	tween(enemyTower, {
		scaleX: enemyTowerScale,
		scaleY: enemyTowerScale
	}, {
		duration: 500,
		easing: tween.easeInOut
	});
}
function updateManaDisplay() {
	// Update text
	manaText.setText('Mana: ' + currentMana + '/' + maxMana);
	// Update orb visuals
	for (var i = 0; i < manaOrbs.length; i++) {
		if (i < currentMana) {
			manaOrbs[i].alpha = 1.0; // Full opacity for available mana
			manaOrbs[i].tint = 0x00FFFF; // Cyan color
		} else {
			manaOrbs[i].alpha = 0.3; // Low opacity for depleted mana
			manaOrbs[i].tint = 0x666666; // Gray color
		}
	}
	// Update note button states based on mana and current combination length
	var requiredMana = currentCombination.length + 1; // Mana needed to add one more note
	for (var i = 0; i < notes.length; i++) {
		if (currentMana < requiredMana) {
			notes[i].alpha = 0.5; // Grayed out when not enough mana
			notes[i].isDisabled = true;
		} else {
			notes[i].alpha = 1.0; // Normal when mana available
			notes[i].isDisabled = false;
		}
	}
}
function playRandomCombatSound() {
	var combatSounds = ['combatir_1', 'combatir_2', 'combatir_3', 'combatir_4'];
	var randomIndex = Math.floor(Math.random() * combatSounds.length);
	var sound = LK.getSound(combatSounds[randomIndex]);
	sound.volume = soundValue;
	sound.play();
}
function sonidoEspadas() {
	var sound = LK.getSound('attack');
	sound.volume = soundValue;
	sound.play();
}
function playRandomProjectileSound(element) {
	var projectileSounds = [];
	if (element === 'water') {
		projectileSounds = ['sonido_proyectil_agua_1', 'sonido_proyectil_agua_2', 'sonido_proyectil_agua_3', 'sonido_proyectil_agua_4'];
	} else if (element === 'wind') {
		projectileSounds = ['sonido_proyectil_viento_1', 'sonido_proyectil_viento_2', 'sonido_proyectil_viento_3', 'sonido_proyectil_viento_4'];
	} else if (element === 'light') {
		projectileSounds = ['sonido_proyectil_energia_1', 'sonido_proyectil_energia_2', 'sonido_proyectil_energia_3', 'sonido_proyectil_energia_4'];
	}
	if (projectileSounds.length > 0) {
		var randomIndex = Math.floor(Math.random() * projectileSounds.length);
		var sound = LK.getSound(projectileSounds[randomIndex]);
		sound.volume = soundValue;
		sound.play();
	}
}
function disableAllNoteButtons() {
	for (var i = 0; i < notes.length; i++) {
		notes[i].isDisabled = true;
		notes[i].alpha = 0.5; // Visual feedback
	}
}
function enableNoteButtons() {
	// Re-enable buttons only if we have enough mana
	updateManaDisplay();
}
function addToCombination(element) {
	currentCombination.push(element);
	combinationTimer = combinationWindowTime;
	combinationCooldown = combinationResetTime;
	// Show current combination
	showCombinationMessage('Combinación: [' + currentCombination.join(', ') + ']');
}
function processCombination() {
	if (currentCombination.length === 0) {
		return;
	}
	// Store combination and timing intervals for melody playback before reset
	var combinationForMelody = currentCombination.slice(); // Create a copy
	var timingIntervalsForMelody = noteTimingIntervals.slice(); // Create a copy of intervals
	// Check if combination is valid
	if (isValidCombination(currentCombination)) {
		// Execute the combination
		executeCombination(currentCombination);
		// Play melody after successful summoning with preserved intervals
		playMelodySequenceWithIntervals(combinationForMelody, timingIntervalsForMelody);
	} else {
		// Show invalid combination message
		showCombinationMessage('Combinación no existente');
	}
	// Reset combination only (element list is managed by crea_combinacion_meteorito)
	// elementList is not reset here - only when meteorite is successfully invoked
	resetCombination();
	// Re-enable buttons after 1 second (invocation phase)
	LK.setTimeout(function () {
		temporaryNoteCounter = 0; // Reset helper counter after invocation phase
		enableNoteButtons();
	}, 1000);
}
function isValidCombination(combination) {
	// Single element combinations are valid
	if (combination.length === 1) {
		var element = combination[0];
		return element === 'fire' || element === 'water' || element === 'earth' || element === 'wind' || element === 'light';
	}
	// Check for meteorite combination first (exactly fire, water, earth, wind, light sequence)
	if (combination.length === 5) {
		var requiredSequence = ['fire', 'water', 'earth', 'wind', 'light'];
		var isMeteorite = true;
		for (var i = 0; i < combination.length; i++) {
			if (combination[i] !== requiredSequence[i]) {
				isMeteorite = false;
				break;
			}
		}
		if (isMeteorite) {
			return true; // Perfect meteorite sequence match
		}
		// If not meteorite sequence, check if all elements are the same for tier 5
		var firstElement = combination[0];
		for (var i = 0; i < combination.length; i++) {
			if (combination[i] !== firstElement) {
				return false;
			}
		}
		// Valid elements for multi-note combinations
		return firstElement === 'fire' || firstElement === 'water' || firstElement === 'earth' || firstElement === 'wind' || firstElement === 'light';
	}
	// Multiple element combinations (2-4 notes of same element)
	if (combination.length >= 2 && combination.length <= 4) {
		var firstElement = combination[0];
		// Check if all elements are the same
		for (var i = 0; i < combination.length; i++) {
			if (combination[i] !== firstElement) {
				return false;
			}
		}
		// Valid elements for multi-note combinations
		return firstElement === 'fire' || firstElement === 'water' || firstElement === 'earth' || firstElement === 'wind' || firstElement === 'light';
	}
	return false;
}
function executeCombination(combination) {
	// Check if we have enough mana for this combination
	if (currentMana < combination.length) {
		showCombinationMessage('No hay suficiente mana');
		return;
	}
	// Consume mana based on combination length
	currentMana -= combination.length;
	updateManaDisplay();
	if (combination.length === 1) {
		// Single element summon
		var element = combination[0];
		summonWarrior(element, 1);
		showCombinationMessage('¡' + element.toUpperCase() + ' nivel 1 invocado!');
	} else if (combination.length >= 2 && combination.length <= 4) {
		// Multiple element combination - create higher tier warrior (2-4 notes)
		var element = combination[0]; // All elements should be the same
		var level = combination.length;
		summonWarrior(element, level);
		showCombinationMessage('¡' + element.toUpperCase() + ' nivel ' + level + ' invocado!');
	} else if (combination.length === 5) {
		// Check if it's the meteorite sequence
		var requiredSequence = ['fire', 'water', 'earth', 'wind', 'light'];
		var isMeteorite = true;
		for (var i = 0; i < combination.length; i++) {
			if (combination[i] !== requiredSequence[i]) {
				isMeteorite = false;
				break;
			}
		}
		if (isMeteorite) {
			// Meteorite combination - summon destructive meteorite with mixed elements
			summonMeteorito();
			showCombinationMessage('¡METEORITO ELEMENTAL INVOCADO!');
		} else {
			// Regular 5-note same element combination
			var element = combination[0];
			summonWarrior(element, 5);
			showCombinationMessage('¡' + element.toUpperCase() + ' nivel 5 invocado!');
		}
	}
}
function summonWarrior(element, tier) {
	// Default tier to 1 if not specified
	if (tier === undefined) {
		tier = 1;
	}
	// Create elemental warrior based on the element and tier
	var warrior = new Warrior(element, tier);
	warrior.x = playerTower.x + 300;
	warrior.y = 2186; // Spawn on ground level
	warrior.onGround = true; // Start on ground
	// Add elemental-specific visual effects on spawn
	var warriorGraphics = warrior.children[0]; // Get the warrior graphics
	if (element === 'water') {
		// Water splash effect - blue particles
		var summonScale = warrior.tierScale * 1.5;
		tween(warriorGraphics, {
			tint: 0x0066ff,
			scaleX: summonScale,
			scaleY: summonScale
		}, {
			duration: 300,
			onFinish: function onFinish() {
				tween(warriorGraphics, {
					tint: 0xffffff,
					scaleX: warrior.tierScale,
					scaleY: warrior.tierScale
				}, {
					duration: 200
				});
			}
		});
	} else if (element === 'earth') {
		// Earth rumble effect - brown particles
		var originalY = warriorGraphics.y;
		tween(warriorGraphics, {
			tint: 0x8b4513,
			y: originalY - 50
		}, {
			duration: 200,
			onFinish: function onFinish() {
				tween(warriorGraphics, {
					tint: 0xffffff,
					y: originalY
				}, {
					duration: 200
				});
			}
		});
	} else if (element === 'fire') {
		// Fire burst effect - red/orange flames
		var summonScale = warrior.tierScale * 1.3;
		tween(warriorGraphics, {
			tint: 0xff4400,
			scaleX: summonScale,
			scaleY: summonScale,
			rotation: Math.PI * 0.1
		}, {
			duration: 250,
			onFinish: function onFinish() {
				tween(warriorGraphics, {
					tint: 0xffffff,
					scaleX: warrior.tierScale,
					scaleY: warrior.tierScale,
					rotation: 0
				}, {
					duration: 150
				});
			}
		});
	} else if (element === 'light') {
		// Lightning effect - bright yellow flash
		var summonScale = warrior.tierScale * 1.2;
		tween(warriorGraphics, {
			tint: 0xffff00,
			alpha: 1.5,
			scaleX: summonScale,
			scaleY: summonScale
		}, {
			duration: 150,
			onFinish: function onFinish() {
				tween(warriorGraphics, {
					tint: 0xffffff,
					alpha: 1.0,
					scaleX: warrior.tierScale,
					scaleY: warrior.tierScale
				}, {
					duration: 100
				});
			}
		});
	} else if (element === 'wind') {
		// Wind swirl effect - green spiral
		var summonScale = warrior.tierScale * 1.1;
		tween(warriorGraphics, {
			tint: 0x44ff44,
			rotation: Math.PI * 2,
			scaleX: summonScale,
			scaleY: summonScale
		}, {
			duration: 400,
			easing: tween.easeOut,
			onFinish: function onFinish() {
				tween(warriorGraphics, {
					tint: 0xffffff,
					rotation: 0,
					scaleX: warrior.tierScale,
					scaleY: warrior.tierScale
				}, {
					duration: 200
				});
			}
		});
	}
	game.addChild(warrior);
	warriors.push(warrior);
	var sound = LK.getSound('summon');
	sound.volume = soundValue;
	sound.play();
	// Add jump effect to all units when any warrior is summoned
	// Make all warriors jump
	for (var i = 0; i < warriors.length; i++) {
		var jumpWarrior = warriors[i];
		// Store current Y position if not already stored
		if (jumpWarrior.baseY === 0) {
			jumpWarrior.baseY = jumpWarrior.y;
		}
		// Apply jump tween - go up then back down
		tween(jumpWarrior, {
			y: jumpWarrior.baseY - 100
		}, {
			duration: 200,
			easing: tween.easeOut,
			onFinish: function onFinish() {
				tween(jumpWarrior, {
					y: jumpWarrior.baseY
				}, {
					duration: 200,
					easing: tween.easeIn
				});
			}
		});
	}
	// Make all enemies jump
	for (var i = 0; i < enemies.length; i++) {
		var jumpEnemy = enemies[i];
		// Store current Y position if not already stored
		if (jumpEnemy.baseY === 0) {
			jumpEnemy.baseY = jumpEnemy.y;
		}
		// Apply jump tween - go up then back down
		tween(jumpEnemy, {
			y: jumpEnemy.baseY - 100
		}, {
			duration: 200,
			easing: tween.easeOut,
			onFinish: function onFinish() {
				tween(jumpEnemy, {
					y: jumpEnemy.baseY
				}, {
					duration: 200,
					easing: tween.easeIn
				});
			}
		});
	}
}
function playMelodySequenceWithIntervals(combination, intervals) {
	// Wait 1 second before starting melody playback to differentiate from invocation
	LK.setTimeout(function () {
		// Play notes sequentially using cumulative timing
		var cumulativeDelay = 0;
		for (var i = 0; i < combination.length; i++) {
			var element = combination[i];
			// First note plays immediately (0ms), subsequent notes use intervals
			var delay = i === 0 ? 0 : cumulativeDelay;
			// Use setTimeout with closure to preserve the element value
			(function (noteElement, currentDelay) {
				LK.setTimeout(function () {
					// Play the appropriate elemental note sound with controlled volume
					if (noteElement === 'fire') {
						var fireSound = LK.getSound('Nota_Fire');
						fireSound.volume = soundValue;
						fireSound.play();
					} else if (noteElement === 'water') {
						var waterSound = LK.getSound('Nota_Water');
						waterSound.volume = soundValue;
						waterSound.play();
					} else if (noteElement === 'earth') {
						var earthSound = LK.getSound('Nota_Earth');
						earthSound.volume = soundValue;
						earthSound.play();
					} else if (noteElement === 'wind') {
						var windSound = LK.getSound('Nota_Wind');
						windSound.volume = soundValue;
						windSound.play();
					} else if (noteElement === 'light') {
						var lightSound = LK.getSound('Nota_Light');
						lightSound.volume = soundValue;
						lightSound.play();
					} else {
						var summonSound = LK.getSound('summon');
						summonSound.volume = soundValue;
						summonSound.play();
					}
				}, currentDelay);
			})(element, delay);
			// Add interval for next note (skip first note since it's 0)
			if (i < intervals.length && i > 0) {
				cumulativeDelay += intervals[i];
			} else if (i === 0 && intervals.length > 1) {
				// For first note, set cumulative delay to the second interval
				cumulativeDelay = intervals[1];
			}
		}
	}, 500); // 0.5 second delay before melody playback
}
function playMelodySequence(combination) {
	// Wait 1 second before starting melody playback to differentiate from invocation
	LK.setTimeout(function () {
		// Play each note in the combination using recorded timing intervals
		var cumulativeDelay = 0;
		for (var i = 0; i < combination.length; i++) {
			var element = combination[i];
			var delay = cumulativeDelay;
			// Use setTimeout with closure to preserve the element value
			(function (noteElement, currentDelay) {
				LK.setTimeout(function () {
					// Play the appropriate elemental note sound with controlled volume
					if (noteElement === 'fire') {
						var fireSound = LK.getSound('Nota_Fire');
						fireSound.volume = soundValue;
						fireSound.play();
					} else if (noteElement === 'water') {
						var waterSound = LK.getSound('Nota_Water');
						waterSound.volume = soundValue;
						waterSound.play();
					} else if (noteElement === 'earth') {
						var earthSound = LK.getSound('Nota_Earth');
						earthSound.volume = soundValue;
						earthSound.play();
					} else if (noteElement === 'wind') {
						var windSound = LK.getSound('Nota_Wind');
						windSound.volume = soundValue;
						windSound.play();
					} else if (noteElement === 'light') {
						var lightSound = LK.getSound('Nota_Light');
						lightSound.volume = soundValue;
						lightSound.play();
					} else {
						var summonSound = LK.getSound('summon');
						summonSound.volume = soundValue;
						summonSound.play();
					}
				}, currentDelay);
			})(element, delay);
			// Update cumulative delay for next note
			if (i < noteTimingIntervals.length) {
				cumulativeDelay += noteTimingIntervals[i];
			} else if (i > 0) {
				// Fallback to 200ms if no interval recorded
				cumulativeDelay += 200;
			}
		}
	}, 1000); // 1 second delay before melody playback
}
function updateElementListDisplay() {
	var listDisplay = 'Lista de Elementos: [' + elementList.map(function (el) {
		return el.toUpperCase();
	}).join(', ') + '] (' + elementList.length + '/' + maxElementList + ')';
	elementListText.setText(listDisplay);
}
function resetCombination() {
	currentCombination = [];
	combinationTimer = 0;
	combinationCooldown = 0;
	temporaryNoteCounter = 0; // Reset helper counter
	// Don't reset timing intervals here - they should persist until new combination starts
	// Only reset when a new note is pressed
	// Update display only when actually clearing intervals
}
function showCombinationMessage(message) {
	combinationMessageText.setText(message);
	combinationMessageText.alpha = 1.0;
	// Fade out message after 2 seconds
	tween(combinationMessageText, {
		alpha: 0
	}, {
		duration: 2000
	});
}
function changeGroundTexture(assetName) {
	// Change ground texture for all tiles
	for (var g = 0; g < groundTiles.length; g++) {
		var oldTile = groundTiles[g];
		// Find the correct index to insert the new tile behind all existing ground tiles
		var insertIndex = 0;
		// Count existing ground tiles to place new tile behind them
		for (var childIndex = 0; childIndex < game.children.length; childIndex++) {
			var child = game.children[childIndex];
			// Check if this child is a ground tile by comparing properties
			if (child.anchor && child.anchor.x === 0.0 && child.anchor.y === 1.0 && child.y === 2732) {
				insertIndex = childIndex + 1; // Place after this ground tile
			}
		}
		var newTile = game.addChildAt(LK.getAsset(assetName, {
			anchorX: 0.0,
			anchorY: 1.0,
			x: oldTile.x,
			y: oldTile.y,
			width: oldTile.width,
			height: oldTile.height
		}), insertIndex);
		// Add tween to smoothly transition between textures
		newTile.alpha = 0;
		tween(newTile, {
			alpha: 1
		}, {
			duration: 500,
			easing: tween.easeInOut,
			onFinish: function onFinish() {
				oldTile.destroy();
			}
		});
		groundTiles[g] = newTile;
	}
}
game.down = function (x, y, obj) {
	// Handle initial touch in game layer directly
	// Store initial touch position for debug
	initialTouchX = x;
	initialTouchY = y;
	currentTouchX = x;
	currentTouchY = y;
	if (touchDebugText && typeof touchDebugText.setText === 'function') {
		touchDebugText.setText('Touch Info: Initial(' + Math.round(x) + ',' + Math.round(y) + ') Current(' + Math.round(x) + ',' + Math.round(y) + ')');
	}
	if (obj.event && obj.event.button === 2) {
		// Right mouse button
		isDragging = true;
		lastMouseX = x;
		obj.event.preventDefault(); // Prevent context menu
	}
};
leftButton.down = function (x, y, obj) {
	// Move camera left
	cameraX -= 100;
	cameraX = Math.max(0, Math.min(cameraX, maxCameraX));
	game.x = -cameraX;
	// Visual feedback
	tween(leftButton, {
		scaleX: 0.9,
		scaleY: 0.9
	}, {
		duration: 100,
		onFinish: function onFinish() {
			tween(leftButton, {
				scaleX: 1.0,
				scaleY: 1.0
			}, {
				duration: 100
			});
		}
	});
};
rightButton.down = function (x, y, obj) {
	// Move camera right
	cameraX += 100;
	cameraX = Math.max(0, Math.min(cameraX, maxCameraX));
	game.x = -cameraX;
	// Visual feedback
	tween(rightButton, {
		scaleX: 0.9,
		scaleY: 0.9
	}, {
		duration: 100,
		onFinish: function onFinish() {
			tween(rightButton, {
				scaleX: 1.0,
				scaleY: 1.0
			}, {
				duration: 100
			});
		}
	});
};
game.up = function (x, y, obj) {
	if (obj.event && obj.event.button === 2) {
		// Right mouse button
		isDragging = false;
	}
};
game.move = function (x, y, obj) {
	if (isDragging) {
		var deltaX = lastMouseX - x;
		cameraX += deltaX;
		cameraX = Math.max(0, Math.min(cameraX, maxCameraX));
		game.x = -cameraX;
		lastMouseX = x;
	}
	// Update current touch position for debug (game coordinates)
	currentTouchX = x;
	currentTouchY = y;
	// Update debug text with both initial and current positions
	if (touchDebugText && typeof touchDebugText.setText === 'function') {
		touchDebugText.setText('Game Move - Initial(' + Math.round(initialTouchX) + ',' + Math.round(initialTouchY) + ') Current(' + Math.round(currentTouchX) + ',' + Math.round(currentTouchY) + ')');
	}
};
// Add GUI move handler for touch tracking
LK.gui.topLeft.move = function (x, y, obj) {
	// Update current touch position for debug (GUI coordinates)
	currentTouchX = x;
	currentTouchY = y;
	// Update debug text with both initial and current positions
	if (touchDebugText && typeof touchDebugText.setText === 'function') {
		touchDebugText.setText('GUI Move - Initial(' + Math.round(initialTouchX) + ',' + Math.round(initialTouchY) + ') Current(' + Math.round(currentTouchX) + ',' + Math.round(currentTouchY) + ')');
	}
};
// Cloud system for background decoration
var clouds = [];
var cloudSpawnTimer = 0;
function createCloud() {
	var cloud = new Nube();
	cloud.x = -200; // Start off-screen left
	// Create clouds randomly between y=0 and y=1000 with depth layering
	cloud.y = Math.random() * 2000; // Random position between y=0 and y=2000
	cloud.startFloating(); // Start floating animation after position is set
	// Determine if cloud is background (behind game) or foreground (in front of game)
	var isBackground = Math.random() < 0.6; // 60% chance to be background
	if (isBackground) {
		// Background clouds - behind game elements, more transparent
		// Scale already randomized in Nube constructor, apply additional uniform background scaling
		var additionalScale = 0.5 + Math.random() * 0.6; // Apply additional 50-110% scaling
		cloud.scaleX *= additionalScale;
		cloud.scaleY *= additionalScale;
		cloud.alpha = 0.4 + Math.random() * 0.5; // Random opacity between 40% and 90%
		cloud.children[0].tint = 0xE0E0E0; // Slightly darker for background effect
		// Add background clouds before other game elements
		game.addChildAt(cloud, 0); // Add at index 0 to be behind everything
	} else {
		// Foreground clouds - in front of game elements, more visible
		// Scale already randomized in Nube constructor, apply additional uniform foreground scaling
		var additionalScale = 0.8 + Math.random() * 0.8; // Apply additional 80-160% scaling
		cloud.scaleX *= additionalScale;
		cloud.scaleY *= additionalScale;
		cloud.alpha = 0.4 + Math.random() * 0.5; // Random opacity between 40% and 90%
		cloud.children[0].tint = 0xF8F8F8; // Brighter for foreground effect
		// Add foreground clouds on top of game elements
		game.addChild(cloud); // Add normally to be in front
	}
	// Vary speed based on position for depth effect
	if (cloud.y < 600) {
		// Higher clouds move slower (distance effect)
		cloud.baseSpeed = cloud.baseSpeed * 0.5;
	} else if (cloud.y > 1400) {
		// Lower clouds move faster (proximity effect)
		cloud.baseSpeed = cloud.baseSpeed * 1.5;
	}
	clouds.push(cloud);
}
function updateClouds() {
	// Note: Cloud movement is now handled by the Nube class update method
	// Spawn new clouds periodically
	cloudSpawnTimer++;
	if (cloudSpawnTimer >= 300 + Math.random() * 600) {
		// Every 5-15 seconds
		createCloud();
		cloudSpawnTimer = 0;
	}
}
// Create initial clouds
for (var i = 0; i < 24; i++) {
	// Doubled number for better coverage
	var cloud = new Nube();
	cloud.x = Math.random() * 4000; // Random initial position across screen
	// Create clouds randomly between y=0 and y=1000 with depth layering
	cloud.y = Math.random() * 2000; // Random position between y=0 and y=2000
	cloud.startFloating(); // Start floating animation after position is set
	// Determine if cloud is background (behind game) or foreground (in front of game)
	var isBackground = Math.random() < 0.6; // 60% chance to be background
	if (isBackground) {
		// Background clouds - behind game elements, more transparent
		// Scale already randomized in Nube constructor, apply additional uniform background scaling
		var additionalScale = 0.5 + Math.random() * 0.6; // Apply additional 50-110% scaling
		cloud.scaleX *= additionalScale;
		cloud.scaleY *= additionalScale;
		cloud.alpha = 0.4 + Math.random() * 0.5; // Random opacity between 40% and 90%
		cloud.children[0].tint = 0xE0E0E0; // Slightly darker for background effect
		// Add background clouds before other game elements
		game.addChildAt(cloud, 0); // Add at index 0 to be behind everything
	} else {
		// Foreground clouds - in front of game elements, more visible
		// Scale already randomized in Nube constructor, apply additional uniform foreground scaling
		var additionalScale = 0.8 + Math.random() * 0.8; // Apply additional 80-160% scaling
		cloud.scaleX *= additionalScale;
		cloud.scaleY *= additionalScale;
		cloud.alpha = 0.4 + Math.random() * 0.5; // Random opacity between 40% and 90%
		cloud.children[0].tint = 0xF8F8F8; // Brighter for foreground effect
		// Add foreground clouds on top of game elements
		game.addChild(cloud); // Add normally to be in front
	}
	// Vary speed based on position for depth effect
	if (cloud.y < 600) {
		// Higher clouds move slower (distance effect)
		cloud.baseSpeed = cloud.baseSpeed * 0.5;
	} else if (cloud.y > 1400) {
		// Lower clouds move faster (proximity effect)
		cloud.baseSpeed = cloud.baseSpeed * 1.5;
	}
	clouds.push(cloud);
}
// Function to simulate music beat detection based on game timing
function getGameMusicLevel() {
	// Simulate music beats based on game ticks and music timing
	// Create a beat pattern that varies over time
	var beatPattern = Math.sin(LK.ticks * 0.1) * 0.3 + 0.5; // Base sine wave
	var strongBeat = Math.sin(LK.ticks * 0.05) * 0.4; // Slower variation for stronger beats
	var randomVariation = (Math.random() - 0.5) * 0.2; // Add some randomness
	// Combine patterns to create realistic music-like variation
	var musicLevel = beatPattern + strongBeat + randomVariation;
	// Ensure the value stays within realistic bounds (0.0 to 1.0)
	musicLevel = Math.max(0, Math.min(1, musicLevel));
	return musicLevel;
}
// Function to initialize element list (lista meteorito)
function initializeElementList() {
	elementList = ['fire', 'water', 'earth', 'wind', 'light'];
	updateElementListDisplay();
}
// Function to create random meteorite combination
function crea_combinacion_meteorito() {
	for (var i = 0; i < 5; i++) {
		// Generate random integer between 0.49 and 5.49, then make it integer
		var randomNumber = Math.floor(Math.random() * 5) + 1; // This gives us 1-5
		var element;
		if (randomNumber === 1) {
			element = 'fire';
		} else if (randomNumber === 2) {
			element = 'water';
		} else if (randomNumber === 3) {
			element = 'earth';
		} else if (randomNumber === 4) {
			element = 'wind';
		} else if (randomNumber === 5) {
			element = 'light';
		}
		elementList.push(element);
	}
	updateElementListDisplay();
}
// Initialize element list with corresponding notes at game start
crea_combinacion_meteorito();
// Start background music with initial volume from slider
LK.playMusic('Music', {
	volume: musicValue
});
// Timer for apocalyptic note revelation (every 10 seconds = 600 frames at 60fps)
var revelacionTimer = 0;
game.update = function () {
	// Music beat detection and character synchronization
	var audioLevel = getGameMusicLevel();
	// Calculate sensitivity difference for debug display
	var sensitivityDifference = Math.max(0, audioLevel - musicBeatThreshold);
	// Update audio debug text in real-time
	if (audioDebugText && typeof audioDebugText.setText === 'function') {
		audioDebugText.setText('Audio: ' + audioLevel.toFixed(3) + ' | Threshold: ' + musicBeatThreshold.toFixed(2) + ' | Diff: ' + sensitivityDifference.toFixed(3));
	}
	// Update revelacion timer and call function every 10 seconds
	revelacionTimer++;
	if (revelacionTimer >= 600) {
		// 10 seconds at 60fps
		revelacion_nota_apocalitica();
		revelacionTimer = 0;
	}
	// Enhanced beat detection with multiple triggers
	var beatDetected = false;
	// Primary beat detection - only when audio level reaches 1
	if (audioLevel >= 1.0 && LK.ticks - lastBeatTime > beatCooldown) {
		beatDetected = true;
	}
	// Remove fallback timer-based beat detection to prevent constant particle spam
	if (beatDetected) {
		// Beat detected - activate effect on all characters
		lastBeatTime = LK.ticks;
		// Activate effect on warriors
		for (var i = 0; i < warriors.length; i++) {
			warriors[i].beatEffectTimer = 120; // 2 seconds of sine wave effect
		}
		// Activate effect on enemies only if they're not golden statues
		for (var i = 0; i < enemies.length; i++) {
			if (!enemies[i].enemigo_oro) {
				enemies[i].beatEffectTimer = 120; // 2 seconds of sine wave effect
			}
		}
		// Activate particle effects on towers instead of scaling
		// Create particles around player tower in cone shape
		for (var p = 0; p < 24; p++) {
			// Calculate cone angle - wider at the top, narrower at bottom
			var angle = (Math.random() - 0.5) * Math.PI * 0.5; // 90 degree cone spread
			var distance = Math.random() * 300 + 100; // Random distance from center
			var startX = playerTower.x + Math.sin(angle) * (distance * 0.3); // Narrow at bottom
			var endX = playerTower.x + Math.sin(angle) * distance; // Wide at top
			var playerTowerCurrentScale = playerTower.scaleX; // Get current tower scale
			var scaledOffsetY = (1728 - 50) * playerTowerCurrentScale; // Scale the Y offset
			var particle = game.addChild(LK.getAsset('particula_torre_jugador', {
				anchorX: 0.5,
				anchorY: 0.5,
				x: startX + 100,
				y: playerTower.y - scaledOffsetY,
				width: 300 + Math.random() * 200,
				height: 300 + Math.random() * 200,
				rotation: Math.PI
			}));
			particle.alpha = 0.8;
			// Animate particles upward to the sky in cone shape and fade out
			tween(particle, {
				y: playerTower.y - 2000 - Math.random() * 500,
				x: endX + 100,
				alpha: 0,
				scaleX: 0.2,
				scaleY: 0.2
			}, {
				duration: 3000 + Math.random() * 500,
				easing: tween.easeOut,
				onFinish: function onFinish() {
					particle.destroy();
				}
			});
		}
		// Create particles around enemy tower in cone shape
		for (var p = 0; p < 24; p++) {
			// Calculate cone angle - wider at the top, narrower at bottom
			var angle = (Math.random() - 0.5) * Math.PI * 0.5; // 90 degree cone spread
			var distance = Math.random() * 300 + 100; // Random distance from center
			var startX = enemyTower.x + Math.sin(angle) * (distance * 0.3); // Narrow at bottom
			var endX = enemyTower.x + Math.sin(angle) * distance; // Wide at top
			var enemyTowerCurrentScale = enemyTower.scaleX; // Get current tower scale
			var scaledOffsetY = (1728 - 50) * enemyTowerCurrentScale; // Scale the Y offset
			var particle = game.addChild(LK.getAsset('particula_torre_enemiga', {
				anchorX: 0.5,
				anchorY: 0.5,
				x: startX,
				y: enemyTower.y - scaledOffsetY,
				width: 300 + Math.random() * 200,
				height: 300 + Math.random() * 200,
				rotation: Math.PI
			}));
			particle.alpha = 0.8;
			// Animate particles upward to the sky in cone shape and fade out
			tween(particle, {
				y: enemyTower.y - 2000 - Math.random() * 500,
				x: endX,
				alpha: 0,
				scaleX: 0.2,
				scaleY: 0.2
			}, {
				duration: 3000 + Math.random() * 500,
				easing: tween.easeOut,
				onFinish: function onFinish() {
					particle.destroy();
				}
			});
		}
	}
	// Mana regeneration - every 10 seconds (600 frames at 60fps)
	manaRegenTimer++;
	if (manaRegenTimer >= 600) {
		if (currentMana < maxMana) {
			currentMana++;
			updateManaDisplay();
		}
		manaRegenTimer = 0;
	}
	// Spawn enemies periodically
	enemySpawnTimer++;
	if (enemySpawnTimer >= 500) {
		// Every 8.3 seconds
		spawnEnemy();
		enemySpawnTimer = 0;
	}
	// Clean up off-screen warriors
	for (var i = warriors.length - 1; i >= 0; i--) {
		var warrior = warriors[i];
		if (warrior.x > 4000) {
			warrior.destroy();
			warriors.splice(i, 1);
		}
	}
	// Clean up off-screen enemies
	for (var i = enemies.length - 1; i >= 0; i--) {
		var enemy = enemies[i];
		if (enemy.x < -200) {
			enemy.destroy();
			enemies.splice(i, 1);
		}
	}
	// Clean up off-screen spores
	for (var i = esporas.length - 1; i >= 0; i--) {
		var espora = esporas[i];
		if (espora.x < -500 || espora.x > 4500 || espora.y > 3500) {
			espora.destroy();
			esporas.splice(i, 1);
		}
	}
	// Update cloud system
	updateClouds();
	// Update temporary counter info text
	tempCounterInfoText.setText('Notas presionadas: ' + temporaryNoteCounter);
	// Check if any fire tier 5 warriors exist
	var hasTier5FireWarrior = false;
	for (var w = 0; w < warriors.length; w++) {
		var warrior = warriors[w];
		if (warrior.element === 'fire' && warrior.tier === 5) {
			hasTier5FireWarrior = true;
			break;
		}
	}
	// Activate fire mode if tier 5 fire warrior exists and mode is not active
	if (hasTier5FireWarrior && !globalFireModeActive) {
		globalFireModeActive = true;
		showCombinationMessage('¡MODO FUEGO ACTIVADO!');
		// Activate red visual effects
		tween(fireOverlay, {
			alpha: 0.2
		}, {
			duration: 500,
			easing: tween.easeInOut
		});
		// Apply red tint to towers
		tween(playerTower, {
			tint: 0xff6666
		}, {
			duration: 500,
			easing: tween.easeInOut
		});
		tween(enemyTower, {
			tint: 0xff6666
		}, {
			duration: 500,
			easing: tween.easeInOut
		});
		// Change ground texture to fire ground
		changeGroundTexture('tileground');
		// Apply red tint to clouds
		for (var c = 0; c < clouds.length; c++) {
			// Store original tint if not already stored
			if (!clouds[c].children[0].originalTint) {
				clouds[c].children[0].originalTint = clouds[c].children[0].tint;
			}
			tween(clouds[c].children[0], {
				tint: 0xff8888
			}, {
				duration: 500,
				easing: tween.easeInOut
			});
		}
	}
	// Deactivate fire mode if no tier 5 fire warriors exist and mode is active
	if (!hasTier5FireWarrior && globalFireModeActive) {
		globalFireModeActive = false;
		showCombinationMessage('Modo fuego desactivado');
		// Fade out red overlay and tints
		tween(fireOverlay, {
			alpha: 0
		}, {
			duration: 1000,
			easing: tween.easeOut
		});
		// Remove red tint from towers
		tween(playerTower, {
			tint: 0xffffff
		}, {
			duration: 1000,
			easing: tween.easeOut
		});
		tween(enemyTower, {
			tint: 0xffffff
		}, {
			duration: 1000,
			easing: tween.easeOut
		});
		// Change ground texture back to normal
		changeGroundTexture('ground');
		// Remove red tint from clouds
		for (var c = 0; c < clouds.length; c++) {
			tween(clouds[c].children[0], {
				tint: clouds[c].children[0].originalTint || 0xF0F0F0
			}, {
				duration: 1000,
				easing: tween.easeOut
			});
		}
	}
	// Process global fire mode effects only if active
	if (globalFireModeActive) {
		// Apply fire damage to all enemies every second
		if (LK.ticks % 60 === 0) {
			for (var i = 0; i < enemies.length; i++) {
				var enemy = enemies[i];
				if (enemy.takeBurnDamage) {
					enemy.takeBurnDamage(0, 1000, 6); // No initial damage, 1 second burn for 6 damage
				}
			}
		}
	}
	// Update apocalypse timer
	tiempoDeApocalipsis++;
	if (tiempoDeApocalipsis >= apocalipsisThreshold) {
		// 5 seconds of no note presses - trigger apocalypse music
		musicaDelApocalipsis();
		tiempoDeApocalipsis = 0; // Reset timer after triggering
	}
	// Update combination system timers
	if (combinationTimer > 0) {
		combinationTimer--;
		if (combinationTimer <= 0 && currentCombination.length > 0) {
			// Time window expired, process current combination
			processCombination();
		}
	}
	if (combinationCooldown > 0) {
		combinationCooldown--;
		if (combinationCooldown <= 0 && currentCombination.length > 0) {
			// Reset timeout reached, clear combination
			showCombinationMessage('Tiempo agotado - Combinación reiniciada');
			resetCombination();
			// Re-enable buttons after timeout
			enableNoteButtons();
		}
	}
};
// Variable i for counting revealed apocalyptic notes
var i = 0;
function revelacion_nota_apocalitica() {
	// Only reveal if i is less than 5 (cannot have more than i=5)
	if (i >= 5) {
		return; // Exit if we've already revealed all 5 notes
	}
	// Get the element from elementList based on current counter i
	if (i < elementList.length) {
		var element = elementList[i];
		// Get the corresponding note image for this element
		var noteImageId = element + 'Note';
		// Update the apocalyptic note casilla with the element's note image
		if (casillas[i]) {
			// Remove current asset and add new one
			casillas[i].destroy();
			// Create new note asset with the element's image
			var newCasilla = LK.getAsset(noteImageId, {
				width: 60,
				height: 60,
				anchorX: 0.5,
				anchorY: 0.5
			});
			newCasilla.x = 409 + i * 70; // Same positioning as original
			newCasilla.y = 220;
			LK.gui.topLeft.addChild(newCasilla);
			casillas[i] = newCasilla;
		}
	}
	// Increment counter by 1 each time function is called
	i++;
}
function ocultar_notas_apocalitica() {
	// Reset counter i to 0
	i = 0;
	// Hide all apocalyptic notes by restoring default lock image
	for (var j = 0; j < casillas.length; j++) {
		if (casillas[j]) {
			// Remove current note image
			casillas[j].destroy();
			// Create new default lock image
			var newCasilla = LK.getAsset('nota_apocalitica', {
				width: 60,
				height: 60,
				anchorX: 0.5,
				anchorY: 0.5
			});
			newCasilla.x = 409 + j * 70; // Same positioning as original
			newCasilla.y = 220;
			LK.gui.topLeft.addChild(newCasilla);
			casillas[j] = newCasilla;
		}
	}
}
function despertar(enemy) {
	// Start 5-second timer to clear both states for this specific enemy
	if (!enemy.clearStatesTimer) {
		enemy.clearStatesTimer = true;
		tween(enemy, {
			alpha: enemy.alpha
		}, {
			duration: 5000,
			onFinish: function onFinish() {
				// Wake up only this specific enemy
				enemy.isSleeping = false;
				enemy.enemigo_oro = false;
				enemy.clearStatesTimer = false;
			}
		});
	}
}
function musicaDelApocalipsis() {
	// Play the meteorite element list with 0.5s intervals between notes
	var combinationForMelody = elementList.slice(); // Create a copy of elementList
	// Create intervals array with 0.5s (500ms) between each note
	var intervalsForMelody = [];
	for (var i = 0; i < combinationForMelody.length; i++) {
		if (i === 0) {
			intervalsForMelody.push(0); // First note plays immediately
		} else {
			intervalsForMelody.push(500); // 0.5s = 500ms delay between notes
		}
	}
	// Play the melody sequence with the meteorite combination
	playMelodySequenceWithIntervals(combinationForMelody, intervalsForMelody);
	// Show apocalypse message
	showCombinationMessage('¡MÚSICA DEL APOCALIPSIS - MELODÍA DEL METEORITO!');
}

===================================================================
--- original.js
+++ change.js
@@ -1890,81 +1890,9 @@
 										enemy.activar_movimiento = false;
 										enemy.canAttack = false;
 										// Remove golden statue effect after some time (permanent for now)
 									}
-									// Tier 3: Sleep particle system
-									else if (proj.sleepParticleSystem) {
-										enemy.isSleeping = true;
-										enemy.activar_movimiento = false;
-										enemy.canAttack = false;
-										enemy.children[0].tint = 0x9999FF; // Sleepy blue color
-										// Add sleep particles
-										for (var sleepP = 0; sleepP < 5; sleepP++) {
-											var sleepParticle = game.addChild(LK.getAsset('particulas_curacion', {
-												anchorX: 0.5,
-												anchorY: 0.5,
-												x: enemy.x + (Math.random() - 0.5) * 60,
-												y: enemy.y - 50 - Math.random() * 30,
-												width: 20,
-												height: 20
-											}));
-											sleepParticle.alpha = 0.8;
-											sleepParticle.tint = 0x9999FF;
-											tween(sleepParticle, {
-												y: sleepParticle.y - 100,
-												alpha: 0,
-												scaleX: 2,
-												scaleY: 2
-											}, {
-												duration: 2000,
-												easing: tween.easeOut,
-												onFinish: function onFinish() {
-													sleepParticle.destroy();
-												}
-											});
-										}
-										// Remove sleep after duration
-										LK.setTimeout(function () {
-											enemy.isSleeping = false;
-											enemy.activar_movimiento = true;
-											enemy.canAttack = true;
-											enemy.children[0].tint = 0xFFFFFF;
-										}, proj.sleepDuration);
-									}
-									// Tier 4: Emerald slave conversion or sleep
-									else if (proj.emeraldSlaveChance) {
-										if (Math.random() < proj.emeraldSlaveChance) {
-											// Convert to emerald slave - destroy enemy and create warrior ally
-											var slaveWarrior = new Warrior('earth', 1); // Create earth warrior as base
-											slaveWarrior.x = enemy.x;
-											slaveWarrior.y = enemy.y;
-											slaveWarrior.health = enemy.health; // Inherit remaining health
-											slaveWarrior.damage = enemy.damage; // Inherit damage
-											slaveWarrior.speed = enemy.speed; // Inherit speed
-											slaveWarrior.children[0].tint = 0x00FF00; // Green emerald tint
-											slaveWarrior.children[0].scaleX = -slaveWarrior.children[0].scaleX; // Mirror horizontally
-											game.addChild(slaveWarrior);
-											warriors.push(slaveWarrior);
-											// Remove original enemy
-											enemy.destroy();
-											var enemyIndex = enemies.indexOf(enemy);
-											if (enemyIndex > -1) {
-												enemies.splice(enemyIndex, 1);
-											}
-										} else {
-											// Apply sleep effect for 10 seconds
-											enemy.isSleeping = true;
-											enemy.activar_movimiento = false;
-											enemy.canAttack = false;
-											enemy.children[0].tint = 0x9999FF;
-											LK.setTimeout(function () {
-												enemy.isSleeping = false;
-												enemy.activar_movimiento = true;
-												enemy.canAttack = true;
-												enemy.children[0].tint = 0xFFFFFF;
-											}, proj.sleepDuration);
-										}
-									}
+									// Wind warrior projectiles only deal damage now - no special effects
 									// Tier 5: Tornado attack
 									else if (proj.tornadoAttack && proj.attackedEnemies.indexOf(enemy) === -1) {
 										proj.attackedEnemies.push(enemy); // Mark enemy as attacked by this projectile
 										enemy.inTornado = true;