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

/**** 
* Classes
****/ 
var CrystalTower = Container.expand(function () {
	var self = Container.call(this);
	self.health = 500;
	self.maxHealth = 500;
	self.range = 200;
	self.damage = 40;
	self.fireRate = 30;
	self.lastShot = 0;
	self.hits = 0;
	self.maxHits = 10;
	// Create magic aura for attack radius visualization
	self.magicAura = new MagicAura();
	self.addChild(self.magicAura);
	// Scale aura to match tower range (range 200 = diameter 400)
	self.magicAura.scaleX = self.range * 2 / 400;
	self.magicAura.scaleY = self.range * 2 / 400;
	var graphics = self.attachAsset('crystalTower', {
		anchorX: 0.5,
		anchorY: 1
	});
	self.takeDamage = function (damage) {
		self.health -= damage;
		self.hits++;
		// Tower blinks red when taking damage
		tween(graphics, {
			tint: 0xff0000
		}, {
			duration: 150,
			easing: tween.easeOut,
			onFinish: function onFinish() {
				tween(graphics, {
					tint: 0xffffff
				}, {
					duration: 150,
					easing: tween.easeOut,
					onFinish: function onFinish() {
						tween(graphics, {
							tint: 0xff0000
						}, {
							duration: 150,
							easing: tween.easeOut,
							onFinish: function onFinish() {
								tween(graphics, {
									tint: 0xffffff
								}, {
									duration: 150,
									easing: tween.easeOut
								});
							}
						});
					}
				});
			}
		});
		LK.effects.flashObject(self, 0xff0000, 500);
		// Add damage effects based on health percentage
		var healthPercent = self.health / self.maxHealth;
		if (healthPercent < 0.7) {
			// Add cracks
			var crack = LK.getAsset('crackEffect', {
				anchorX: 0.5,
				anchorY: 0.5
			});
			crack.x = self.x + (Math.random() - 0.5) * 100;
			crack.y = self.y - Math.random() * 150;
			crack.rotation = Math.random() * Math.PI;
			crack.alpha = 0.8;
			game.addChild(crack);
		}
		if (healthPercent < 0.5) {
			// Add smoke effects
			var smoke = new SmokeEffect();
			smoke.x = self.x + (Math.random() - 0.5) * 80;
			smoke.y = self.y - 100 - Math.random() * 50;
			game.addChild(smoke);
		}
		if (healthPercent < 0.3) {
			// Add red alert glow
			LK.effects.flashScreen(0xff0000, 300);
		}
		if (self.hits >= self.maxHits) {
			// Create massive explosion effect
			for (var i = 0; i < 5; i++) {
				var explosion = new ExplosionEffect();
				explosion.x = self.x + (Math.random() - 0.5) * 150;
				explosion.y = self.y - Math.random() * 200;
				game.addChild(explosion);
			}
			// Play destruction sound
			LK.getSound('towerDestroy').play();
			// Flash screen red for dramatic effect
			LK.effects.flashScreen(0xff0000, 1500);
			LK.showGameOver();
		}
	};
	self.findTarget = function () {
		var closest = null;
		var closestDistance = self.range;
		for (var i = 0; i < enemies.length; i++) {
			var enemy = enemies[i];
			var dx = enemy.x - self.x;
			var dy = enemy.y - self.y;
			var distance = Math.sqrt(dx * dx + dy * dy);
			if (distance < closestDistance) {
				closest = enemy;
				closestDistance = distance;
			}
		}
		return closest;
	};
	self.shoot = function (target) {
		if (LK.ticks - self.lastShot >= self.fireRate) {
			var projectile = new TowerProjectile();
			projectile.x = self.x;
			projectile.y = self.y - 60;
			projectile.target = target;
			projectile.damage = self.damage;
			game.addChild(projectile);
			towerProjectiles.push(projectile);
			self.lastShot = LK.ticks;
			// Trigger magical attack aura effect
			self.magicAura.showAttackPulse();
			// Add magical flash effect to tower
			LK.effects.flashObject(graphics, 0x4169e1, 500);
			// Add muzzle flash
			var flash = new MuzzleFlash();
			flash.x = self.x;
			flash.y = self.y - 80;
			game.addChild(flash);
			LK.getSound('towerShoot').play();
		}
	};
	self.update = function () {
		var target = self.findTarget();
		if (target) {
			self.shoot(target);
		}
	};
	return self;
});
var Enemy = Container.expand(function (type) {
	var self = Container.call(this);
	self.enemyType = type || 'goblin';
	self.health = 100;
	self.maxHealth = 100;
	self.speed = 1;
	self.goldValue = 10;
	self.currentTarget = null;
	self.lastX = 0;
	self.lastY = 0;
	self.dustTimer = 0;
	self.motionEffects = [];
	if (self.enemyType === 'goblin') {
		self.health = 80;
		self.maxHealth = 80;
		self.speed = 1.5;
		self.goldValue = 15;
		var graphics = self.attachAsset('goblin', {
			anchorX: 0.5,
			anchorY: 1
		});
	} else if (self.enemyType === 'troll') {
		self.health = 200;
		self.maxHealth = 200;
		self.speed = 0.8;
		self.goldValue = 30;
		var graphics = self.attachAsset('troll', {
			anchorX: 0.5,
			anchorY: 1
		});
	} else if (self.enemyType === 'skeleton') {
		self.health = 120;
		self.maxHealth = 120;
		self.speed = 1.2;
		self.goldValue = 20;
		var graphics = self.attachAsset('skeleton', {
			anchorX: 0.5,
			anchorY: 1
		});
	}
	// Add glowing red eyes
	self.redEyes = self.attachAsset('redEyes', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.redEyes.y = -graphics.height * 0.8;
	// Make eyes glow with pulsing effect
	self.eyeGlowDirection = 1;
	self.eyeGlowAlpha = 0.8;
	self.targetX = 1024;
	self.targetY = 1366;
	self.findNearestTarget = function () {
		var nearestTarget = null;
		var shortestDistance = Infinity;
		// Check crystal tower
		var dx = crystalTower.x - self.x;
		var dy = crystalTower.y - self.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		nearestTarget = crystalTower;
		shortestDistance = distance;
		// Check hero
		dx = hero.x - self.x;
		dy = hero.y - self.y;
		distance = Math.sqrt(dx * dx + dy * dy);
		if (distance < shortestDistance) {
			nearestTarget = hero;
			shortestDistance = distance;
		}
		// Check towers
		for (var i = 0; i < towers.length; i++) {
			var tower = towers[i];
			dx = tower.x - self.x;
			dy = tower.y - self.y;
			distance = Math.sqrt(dx * dx + dy * dy);
			if (distance < shortestDistance) {
				nearestTarget = tower;
				shortestDistance = distance;
			}
		}
		return nearestTarget;
	};
	self.createDustCloud = function () {
		var dust = LK.getAsset('dustCloud', {
			anchorX: 0.5,
			anchorY: 0.5
		});
		dust.x = self.x + (Math.random() - 0.5) * 30;
		dust.y = self.y + (Math.random() - 0.5) * 20;
		dust.alpha = 0.6;
		game.addChild(dust);
		// Animate dust cloud
		tween(dust, {
			alpha: 0,
			scaleX: 1.5,
			scaleY: 1.5,
			y: dust.y - 20
		}, {
			duration: 800,
			easing: tween.easeOut,
			onFinish: function onFinish() {
				dust.destroy();
			}
		});
	};
	self.createMotionLine = function () {
		var motionLine = LK.getAsset('motionLine', {
			anchorX: 0,
			anchorY: 0.5
		});
		motionLine.x = self.x - 40;
		motionLine.y = self.y - 20;
		motionLine.alpha = 0.7;
		// Calculate motion direction for line orientation
		var dx = self.x - self.lastX;
		var dy = self.y - self.lastY;
		if (dx !== 0 || dy !== 0) {
			motionLine.rotation = Math.atan2(dy, dx);
		}
		game.addChild(motionLine);
		self.motionEffects.push(motionLine);
		// Fade out motion line
		tween(motionLine, {
			alpha: 0,
			scaleX: 0.5
		}, {
			duration: 600,
			easing: tween.easeOut,
			onFinish: function onFinish() {
				for (var i = self.motionEffects.length - 1; i >= 0; i--) {
					if (self.motionEffects[i] === motionLine) {
						self.motionEffects.splice(i, 1);
						break;
					}
				}
				motionLine.destroy();
			}
		});
	};
	self.takeDamage = function (damage) {
		self.health -= damage;
		if (self.health <= 0) {
			self.die();
		}
	};
	self.die = function () {
		// Clean up motion effects
		for (var i = 0; i < self.motionEffects.length; i++) {
			self.motionEffects[i].destroy();
		}
		var coin = new GoldCoin();
		coin.x = self.x;
		coin.y = self.y;
		coin.value = self.goldValue;
		game.addChild(coin);
		goldCoins.push(coin);
		LK.getSound('enemyDeath').play();
		for (var i = enemies.length - 1; i >= 0; i--) {
			if (enemies[i] === self) {
				enemies.splice(i, 1);
				break;
			}
		}
		self.destroy();
	};
	self.update = function () {
		// Store last position for motion effects
		self.lastX = self.x;
		self.lastY = self.y;
		// Update glowing eyes effect
		self.eyeGlowAlpha += self.eyeGlowDirection * 0.05;
		if (self.eyeGlowAlpha >= 1) {
			self.eyeGlowDirection = -1;
		} else if (self.eyeGlowAlpha <= 0.5) {
			self.eyeGlowDirection = 1;
		}
		self.redEyes.alpha = self.eyeGlowAlpha;
		// Find nearest target and charge toward it
		self.currentTarget = self.findNearestTarget();
		var targetX = self.currentTarget.x;
		var targetY = self.currentTarget.y;
		var dx = targetX - self.x;
		var dy = targetY - self.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		if (distance > 5) {
			// Move toward target with charging behavior
			var moveX = dx / distance * self.speed;
			var moveY = dy / distance * self.speed;
			self.x += moveX;
			self.y += moveY;
			// Create dust clouds periodically while moving
			self.dustTimer++;
			if (self.dustTimer >= 15) {
				self.createDustCloud();
				self.dustTimer = 0;
			}
			// Create motion lines for charging effect
			if (LK.ticks % 8 === 0) {
				self.createMotionLine();
			}
		} else {
			// Attack the target
			if (self.currentTarget === crystalTower) {
				crystalTower.takeDamage(20);
			} else if (self.currentTarget === hero) {
				// Flash hero red when attacked
				LK.effects.flashObject(hero, 0xff0000, 500);
				// Damage hero
				heroHealth -= 25;
				if (heroHealth <= 0 && !heroCollapsed) {
					heroCollapsed = true;
					// Hero collapse effect
					tween(hero, {
						alpha: 0.3,
						scaleX: 0.8,
						scaleY: 0.4,
						rotation: Math.PI / 2
					}, {
						duration: 1000,
						easing: tween.easeOut
					});
					// Add smoke effect
					var smoke = new SmokeEffect();
					smoke.x = hero.x;
					smoke.y = hero.y;
					game.addChild(smoke);
				}
			} else {
				// Check if target is a tower
				for (var i = 0; i < towers.length; i++) {
					if (towers[i] === self.currentTarget) {
						self.currentTarget.takeDamage();
						break;
					}
				}
			}
			self.die();
		}
	};
	return self;
});
var ExplosionEffect = Container.expand(function () {
	var self = Container.call(this);
	var graphics = self.attachAsset('explosion', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	graphics.alpha = 0.8;
	self.scaleX = 0.3;
	self.scaleY = 0.3;
	// Animate explosion
	tween(self, {
		scaleX: 2,
		scaleY: 2,
		alpha: 0
	}, {
		duration: 600,
		easing: tween.easeOut,
		onFinish: function onFinish() {
			self.destroy();
		}
	});
	return self;
});
var GoldCoin = Container.expand(function () {
	var self = Container.call(this);
	var graphics = self.attachAsset('goldCoin', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.value = 10;
	self.collected = false;
	self.collect = function () {
		if (!self.collected) {
			self.collected = true;
			gold += self.value;
			goldText.setText('Gold: ' + gold);
			LK.getSound('coinCollect').play();
			for (var i = goldCoins.length - 1; i >= 0; i--) {
				if (goldCoins[i] === self) {
					goldCoins.splice(i, 1);
					break;
				}
			}
			self.destroy();
		}
	};
	self.down = function (x, y, obj) {
		self.collect();
	};
	return self;
});
var GrassPatch = Container.expand(function (grassType) {
	var self = Container.call(this);
	self.grassType = grassType || 'grassPatch';
	self.swayAmount = 0.1 + Math.random() * 0.15; // Random sway intensity
	self.swaySpeed = 2000 + Math.random() * 1000; // Random sway duration
	var graphics = self.attachAsset(self.grassType, {
		anchorX: 0.5,
		anchorY: 1
	});
	// Start initial sway animation
	self.startSway = function () {
		var targetRotation = self.swayAmount * (Math.random() > 0.5 ? 1 : -1);
		tween(self, {
			rotation: targetRotation
		}, {
			duration: self.swaySpeed,
			easing: tween.easeInOut,
			onFinish: function onFinish() {
				// Reverse sway direction
				var reverseRotation = -targetRotation * (0.8 + Math.random() * 0.4);
				tween(self, {
					rotation: reverseRotation
				}, {
					duration: self.swaySpeed * (0.8 + Math.random() * 0.4),
					easing: tween.easeInOut,
					onFinish: function onFinish() {
						self.startSway(); // Continue swaying indefinitely
					}
				});
			}
		});
	};
	// Start swaying with random delay to create natural effect
	LK.setTimeout(function () {
		self.startSway();
	}, Math.random() * 2000);
	return self;
});
var Hero = Container.expand(function () {
	var self = Container.call(this);
	var graphics = self.attachAsset('hero', {
		anchorX: 0.5,
		anchorY: 1
	});
	self.speed = 3;
	self.range = 450;
	self.damage = 35;
	self.fireRate = 20;
	self.lastShot = 0;
	self.findTarget = function () {
		var closest = null;
		var closestDistance = self.range;
		for (var i = 0; i < enemies.length; i++) {
			var enemy = enemies[i];
			var dx = enemy.x - self.x;
			var dy = enemy.y - self.y;
			var distance = Math.sqrt(dx * dx + dy * dy);
			if (distance < closestDistance) {
				closest = enemy;
				closestDistance = distance;
			}
		}
		return closest;
	};
	self.shoot = function (target) {
		if (LK.ticks - self.lastShot >= self.fireRate) {
			var projectile = new HeroProjectile();
			projectile.x = self.x;
			projectile.y = self.y - 25;
			projectile.target = target;
			projectile.damage = self.damage;
			game.addChild(projectile);
			heroProjectiles.push(projectile);
			self.lastShot = LK.ticks;
		}
	};
	self.update = function () {
		var target = self.findTarget();
		if (target) {
			self.shoot(target);
		}
	};
	return self;
});
var HeroProjectile = Container.expand(function () {
	var self = Container.call(this);
	var graphics = self.attachAsset('heroProjectile', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.speed = 10;
	self.target = null;
	self.damage = 35;
	self.update = function () {
		if (!self.target || self.target.destroyed) {
			self.destroy();
			for (var i = heroProjectiles.length - 1; i >= 0; i--) {
				if (heroProjectiles[i] === self) {
					heroProjectiles.splice(i, 1);
					break;
				}
			}
			return;
		}
		var dx = self.target.x - self.x;
		var dy = self.target.y - self.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		if (distance < 20) {
			self.target.takeDamage(self.damage);
			LK.getSound('arrowImpact').play();
			self.destroy();
			for (var i = heroProjectiles.length - 1; i >= 0; i--) {
				if (heroProjectiles[i] === self) {
					heroProjectiles.splice(i, 1);
					break;
				}
			}
		} else {
			self.x += dx / distance * self.speed;
			self.y += dy / distance * self.speed;
		}
	};
	return self;
});
var MagicAura = Container.expand(function () {
	var self = Container.call(this);
	var graphics = self.attachAsset('magicAura', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	graphics.alpha = 0.2;
	self.pulseDirection = 1;
	self.basePulse = 0.15;
	self.currentPulse = self.basePulse;
	self.update = function () {
		// Create pulsing effect
		self.currentPulse += self.pulseDirection * 0.003;
		if (self.currentPulse >= 0.4) {
			self.pulseDirection = -1;
		} else if (self.currentPulse <= self.basePulse) {
			self.pulseDirection = 1;
		}
		graphics.alpha = self.currentPulse;
		// Slight rotation for magical effect
		graphics.rotation += 0.01;
	};
	self.showAttackPulse = function () {
		// Flash brighter when tower attacks
		tween(graphics, {
			alpha: 0.7,
			scaleX: 1.2,
			scaleY: 1.2
		}, {
			duration: 300,
			easing: tween.easeOut,
			onFinish: function onFinish() {
				tween(graphics, {
					alpha: self.currentPulse,
					scaleX: 1,
					scaleY: 1
				}, {
					duration: 200,
					easing: tween.easeIn
				});
			}
		});
	};
	return self;
});
var MuzzleFlash = Container.expand(function () {
	var self = Container.call(this);
	var graphics = self.attachAsset('muzzleFlash', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	graphics.alpha = 0.9;
	self.scaleX = 0.5;
	self.scaleY = 0.5;
	// Quick flash effect
	tween(self, {
		scaleX: 1.5,
		scaleY: 1.5,
		alpha: 0
	}, {
		duration: 200,
		easing: tween.easeOut,
		onFinish: function onFinish() {
			self.destroy();
		}
	});
	return self;
});
var SmokeEffect = Container.expand(function () {
	var self = Container.call(this);
	var graphics = self.attachAsset('smokeCloud', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	graphics.alpha = 0.4;
	self.scaleX = 0.8;
	self.scaleY = 0.8;
	// Rising smoke animation
	tween(self, {
		y: self.y - 100,
		scaleX: 1.5,
		scaleY: 1.5,
		alpha: 0
	}, {
		duration: 2000,
		easing: tween.easeOut,
		onFinish: function onFinish() {
			self.destroy();
		}
	});
	return self;
});
var Tower = Container.expand(function (type) {
	var self = Container.call(this);
	self.towerType = type || 'archer';
	self.range = 150;
	self.damage = 25;
	self.fireRate = 60;
	self.lastShot = 0;
	self.hits = 0;
	self.maxHits = 4;
	if (self.towerType === 'archer') {
		self.range = 180;
		self.damage = 30;
		self.fireRate = 45;
		var graphics = self.attachAsset('archerTower', {
			anchorX: 0.5,
			anchorY: 1
		});
	} else if (self.towerType === 'cannon') {
		self.range = 120;
		self.damage = 60;
		self.fireRate = 90;
		var graphics = self.attachAsset('cannonTower', {
			anchorX: 0.5,
			anchorY: 1
		});
	}
	self.takeDamage = function () {
		self.hits++;
		// Tower blinks red when taking damage
		tween(graphics, {
			tint: 0xff0000
		}, {
			duration: 200,
			easing: tween.easeOut,
			onFinish: function onFinish() {
				tween(graphics, {
					tint: 0xffffff
				}, {
					duration: 200,
					easing: tween.easeOut
				});
			}
		});
		if (self.hits >= self.maxHits) {
			// Create explosion effect
			var explosion = new ExplosionEffect();
			explosion.x = self.x;
			explosion.y = self.y;
			game.addChild(explosion);
			// Play destruction sound
			LK.getSound('towerDestroy').play();
			// Remove from towers array
			for (var i = towers.length - 1; i >= 0; i--) {
				if (towers[i] === self) {
					towers.splice(i, 1);
					break;
				}
			}
			self.destroy();
		}
	};
	self.findTarget = function () {
		var closest = null;
		var closestDistance = self.range;
		for (var i = 0; i < enemies.length; i++) {
			var enemy = enemies[i];
			var dx = enemy.x - self.x;
			var dy = enemy.y - self.y;
			var distance = Math.sqrt(dx * dx + dy * dy);
			if (distance < closestDistance) {
				closest = enemy;
				closestDistance = distance;
			}
		}
		return closest;
	};
	self.shoot = function (target) {
		if (LK.ticks - self.lastShot >= self.fireRate) {
			var projectile = new TowerProjectile();
			projectile.x = self.x;
			projectile.y = self.y - 40;
			projectile.target = target;
			projectile.damage = self.damage;
			game.addChild(projectile);
			towerProjectiles.push(projectile);
			self.lastShot = LK.ticks;
			LK.getSound('towerShoot').play();
			// Add muzzle flash effect
			var flash = new MuzzleFlash();
			flash.x = self.x;
			flash.y = self.y - 30;
			game.addChild(flash);
		}
	};
	self.update = function () {
		var target = self.findTarget();
		if (target) {
			self.shoot(target);
		}
	};
	return self;
});
var TowerProjectile = Container.expand(function () {
	var self = Container.call(this);
	var graphics = self.attachAsset('towerProjectile', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.speed = 8;
	self.target = null;
	self.damage = 25;
	self.update = function () {
		if (!self.target || self.target.destroyed) {
			self.destroy();
			for (var i = towerProjectiles.length - 1; i >= 0; i--) {
				if (towerProjectiles[i] === self) {
					towerProjectiles.splice(i, 1);
					break;
				}
			}
			return;
		}
		var dx = self.target.x - self.x;
		var dy = self.target.y - self.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		if (distance < 20) {
			self.target.takeDamage(self.damage);
			self.destroy();
			for (var i = towerProjectiles.length - 1; i >= 0; i--) {
				if (towerProjectiles[i] === self) {
					towerProjectiles.splice(i, 1);
					break;
				}
			}
		} else {
			self.x += dx / distance * self.speed;
			self.y += dy / distance * self.speed;
		}
	};
	return self;
});

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

/**** 
* Game Code
****/ 
var enemies = [];
var towers = [];
var towerProjectiles = [];
var heroProjectiles = [];
var goldCoins = [];
var crystalTower;
var hero;
var gold = 100;
var wave = 1;
var enemiesInWave = 5;
var enemySpawnTimer = 0;
var enemiesSpawned = 0;
var waveComplete = false;
var draggedHero = false;
var heroCollapsed = false;
var heroHealth = 100;
var heroMaxHealth = 100;
// Create animated grass background
var grassPatches = [];
for (var i = 0; i < 80; i++) {
	var grassTypes = ['grassPatch', 'tallGrass', 'smallGrass'];
	var randomType = grassTypes[Math.floor(Math.random() * grassTypes.length)];
	var grass = new GrassPatch(randomType);
	// Position grass randomly across the field, avoiding center area
	var angle = Math.random() * Math.PI * 2;
	var distance = 300 + Math.random() * 800; // Keep grass away from center tower area
	grass.x = 1024 + Math.cos(angle) * distance;
	grass.y = 1366 + Math.sin(angle) * distance;
	// Ensure grass stays within bounds
	grass.x = Math.max(50, Math.min(1998, grass.x));
	grass.y = Math.max(50, Math.min(2682, grass.y));
	// Add some scale variation for natural look
	var scale = 0.8 + Math.random() * 0.4;
	grass.scaleX = scale;
	grass.scaleY = scale;
	// Tint variation for more natural grass colors
	var tintVariation = 0.9 + Math.random() * 0.2;
	grass.tint = 0x228B22 * tintVariation;
	game.addChild(grass);
	grassPatches.push(grass);
}
// Create crystal tower at center
crystalTower = new CrystalTower();
crystalTower.x = 1024;
crystalTower.y = 1366;
game.addChild(crystalTower);
// Create hero
hero = new Hero();
hero.x = 900;
hero.y = 1200;
game.addChild(hero);
// UI Elements
var goldText = new Text2('Gold: ' + gold, {
	size: 60,
	fill: 0xFFD700
});
goldText.anchor.set(0, 0);
LK.gui.topRight.addChild(goldText);
goldText.x = -200;
goldText.y = 20;
var waveText = new Text2('Wave: ' + wave, {
	size: 60,
	fill: 0xFFFFFF
});
waveText.anchor.set(0, 0);
LK.gui.top.addChild(waveText);
waveText.x = -100;
waveText.y = 20;
var healthText = new Text2('Tower HP: ' + crystalTower.health, {
	size: 50,
	fill: 0x00FFFF
});
healthText.anchor.set(0, 0);
LK.gui.bottom.addChild(healthText);
healthText.x = -150;
healthText.y = -80;
// Tower placement UI
var archerButton = LK.getAsset('uiPanel', {
	anchorX: 0.5,
	anchorY: 0.5
});
archerButton.x = 150;
archerButton.y = -150;
LK.gui.bottom.addChild(archerButton);
var archerText = new Text2('Archer\n50g', {
	size: 30,
	fill: 0xFFFFFF
});
archerText.anchor.set(0.5, 0.5);
archerButton.addChild(archerText);
var cannonButton = LK.getAsset('uiPanel', {
	anchorX: 0.5,
	anchorY: 0.5
});
cannonButton.x = 400;
cannonButton.y = -150;
LK.gui.bottom.addChild(cannonButton);
var cannonText = new Text2('Cannon\n80g', {
	size: 30,
	fill: 0xFFFFFF
});
cannonText.anchor.set(0.5, 0.5);
cannonButton.addChild(cannonText);
// Tower placement handlers
archerButton.down = function (x, y, obj) {
	if (gold >= 50) {
		placingTowerType = 'archer';
		placingTowerCost = 50;
	}
};
cannonButton.down = function (x, y, obj) {
	if (gold >= 80) {
		placingTowerType = 'cannon';
		placingTowerCost = 80;
	}
};
var placingTowerType = null;
var placingTowerCost = 0;
function spawnEnemy() {
	var enemyTypes = ['goblin', 'goblin', 'skeleton'];
	if (wave >= 3) enemyTypes.push('troll');
	if (wave >= 5) enemyTypes.push('troll', 'troll');
	var randomType = enemyTypes[Math.floor(Math.random() * enemyTypes.length)];
	var enemy = new Enemy(randomType);
	// Spawn from random edge
	var side = Math.floor(Math.random() * 4);
	if (side === 0) {
		// Top
		enemy.x = Math.random() * 2048;
		enemy.y = 0;
	} else if (side === 1) {
		// Right
		enemy.x = 2048;
		enemy.y = Math.random() * 2732;
	} else if (side === 2) {
		// Bottom
		enemy.x = Math.random() * 2048;
		enemy.y = 2732;
	} else {
		// Left
		enemy.x = 0;
		enemy.y = Math.random() * 2732;
	}
	game.addChild(enemy);
	enemies.push(enemy);
	enemiesSpawned++;
}
function checkWaveComplete() {
	if (enemiesSpawned >= enemiesInWave && enemies.length === 0) {
		waveComplete = true;
		wave++;
		enemiesInWave += 2;
		enemiesSpawned = 0;
		waveComplete = false;
		waveText.setText('Wave: ' + wave);
		if (wave > 10) {
			LK.showYouWin();
		}
	}
}
game.down = function (x, y, obj) {
	if (placingTowerType) {
		// Check if position is valid (not too close to crystal tower or other towers)
		var tooClose = false;
		var dx = x - crystalTower.x;
		var dy = y - crystalTower.y;
		if (Math.sqrt(dx * dx + dy * dy) < 200) {
			tooClose = true;
		}
		for (var i = 0; i < towers.length; i++) {
			var tower = towers[i];
			var dx = x - tower.x;
			var dy = y - tower.y;
			if (Math.sqrt(dx * dx + dy * dy) < 120) {
				tooClose = true;
				break;
			}
		}
		if (!tooClose) {
			var newTower = new Tower(placingTowerType);
			newTower.x = x;
			newTower.y = y;
			game.addChild(newTower);
			towers.push(newTower);
			gold -= placingTowerCost;
			goldText.setText('Gold: ' + gold);
			LK.getSound('towerPlace').play();
		}
		placingTowerType = null;
		placingTowerCost = 0;
	} else {
		// Check if clicking on hero to start drag
		var dx = x - hero.x;
		var dy = y - hero.y;
		if (Math.sqrt(dx * dx + dy * dy) < 50) {
			draggedHero = true;
		}
	}
};
game.move = function (x, y, obj) {
	if (draggedHero) {
		hero.x = x;
		hero.y = y;
	}
};
game.up = function (x, y, obj) {
	draggedHero = false;
};
game.update = function () {
	// Spawn enemies
	if (enemiesSpawned < enemiesInWave) {
		enemySpawnTimer++;
		if (enemySpawnTimer >= 120) {
			// Spawn every 2 seconds
			spawnEnemy();
			enemySpawnTimer = 0;
		}
	}
	// Update health display
	healthText.setText('Tower HP: ' + crystalTower.health);
	// Check for hero collecting coins
	for (var i = goldCoins.length - 1; i >= 0; i--) {
		var coin = goldCoins[i];
		var dx = coin.x - hero.x;
		var dy = coin.y - hero.y;
		if (Math.sqrt(dx * dx + dy * dy) < 40) {
			coin.collect();
		}
	}
	// Add random battlefield explosions during intense moments
	if (enemies.length > 8 && LK.ticks % 180 === 0) {
		var explosion = new ExplosionEffect();
		explosion.x = 200 + Math.random() * 1648;
		explosion.y = 200 + Math.random() * 2332;
		game.addChild(explosion);
	}
	// Add red alert glow when tower health is critical
	if (crystalTower.health < crystalTower.maxHealth * 0.2 && LK.ticks % 60 === 0) {
		LK.effects.flashScreen(0x8b0000, 200);
	}
	checkWaveComplete();
};

===================================================================
--- original.js
+++ change.js
@@ -13,8 +13,10 @@
 	self.range = 200;
 	self.damage = 40;
 	self.fireRate = 30;
 	self.lastShot = 0;
+	self.hits = 0;
+	self.maxHits = 10;
 	// Create magic aura for attack radius visualization
 	self.magicAura = new MagicAura();
 	self.addChild(self.magicAura);
 	// Scale aura to match tower range (range 200 = diameter 400)
@@ -25,8 +27,9 @@
 		anchorY: 1
 	});
 	self.takeDamage = function (damage) {
 		self.health -= damage;
+		self.hits++;
 		// Tower blinks red when taking damage
 		tween(graphics, {
 			tint: 0xff0000
 		}, {
@@ -82,16 +85,18 @@
 		if (healthPercent < 0.3) {
 			// Add red alert glow
 			LK.effects.flashScreen(0xff0000, 300);
 		}
-		if (self.health <= 0) {
+		if (self.hits >= self.maxHits) {
 			// Create massive explosion effect
 			for (var i = 0; i < 5; i++) {
 				var explosion = new ExplosionEffect();
 				explosion.x = self.x + (Math.random() - 0.5) * 150;
 				explosion.y = self.y - Math.random() * 200;
 				game.addChild(explosion);
 			}
+			// Play destruction sound
+			LK.getSound('towerDestroy').play();
 			// Flash screen red for dramatic effect
 			LK.effects.flashScreen(0xff0000, 1500);
 			LK.showGameOver();
 		}
@@ -366,8 +371,16 @@
 					smoke.x = hero.x;
 					smoke.y = hero.y;
 					game.addChild(smoke);
 				}
+			} else {
+				// Check if target is a tower
+				for (var i = 0; i < towers.length; i++) {
+					if (towers[i] === self.currentTarget) {
+						self.currentTarget.takeDamage();
+						break;
+					}
+				}
 			}
 			self.die();
 		}
 	};
@@ -646,8 +659,10 @@
 	self.range = 150;
 	self.damage = 25;
 	self.fireRate = 60;
 	self.lastShot = 0;
+	self.hits = 0;
+	self.maxHits = 4;
 	if (self.towerType === 'archer') {
 		self.range = 180;
 		self.damage = 30;
 		self.fireRate = 45;
@@ -663,8 +678,43 @@
 			anchorX: 0.5,
 			anchorY: 1
 		});
 	}
+	self.takeDamage = function () {
+		self.hits++;
+		// Tower blinks red when taking damage
+		tween(graphics, {
+			tint: 0xff0000
+		}, {
+			duration: 200,
+			easing: tween.easeOut,
+			onFinish: function onFinish() {
+				tween(graphics, {
+					tint: 0xffffff
+				}, {
+					duration: 200,
+					easing: tween.easeOut
+				});
+			}
+		});
+		if (self.hits >= self.maxHits) {
+			// Create explosion effect
+			var explosion = new ExplosionEffect();
+			explosion.x = self.x;
+			explosion.y = self.y;
+			game.addChild(explosion);
+			// Play destruction sound
+			LK.getSound('towerDestroy').play();
+			// Remove from towers array
+			for (var i = towers.length - 1; i >= 0; i--) {
+				if (towers[i] === self) {
+					towers.splice(i, 1);
+					break;
+				}
+			}
+			self.destroy();
+		}
+	};
 	self.findTarget = function () {
 		var closest = null;
 		var closestDistance = self.range;
 		for (var i = 0; i < enemies.length; i++) {