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

/**** 
* Classes
****/ 
var Boss = Container.expand(function () {
	var self = Container.call(this);
	self.health = Math.floor(8000 * difficultyScaling.healthMultiplier);
	self.maxHealth = Math.floor(8000 * difficultyScaling.healthMultiplier);
	self.speed = 0.6;
	self.goldValue = 100;
	self.currentTarget = null;
	self.lastX = 0;
	self.lastY = 0;
	self.dustTimer = 0;
	self.motionEffects = [];
	var graphics = self.attachAsset('boos', {
		anchorX: 0.5,
		anchorY: 1
	});
	// Scale boss to be larger
	graphics.scaleX = 1.5;
	graphics.scaleY = 1.5;
	graphics.tint = 0x800080; // Purple tint for boss
	// Add glowing red eyes
	self.redEyes = self.attachAsset('redEyes', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.redEyes.y = -graphics.height * 0.8;
	self.redEyes.scaleX = 1.5;
	self.redEyes.scaleY = 1.5;
	// 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: Math.floor(800 / gameSpeed),
			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: Math.floor(600 / gameSpeed),
			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();
		bossActive = false;
		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 * gameSpeed;
		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 * gameSpeed;
			var moveY = dy / distance * self.speed * gameSpeed;
			self.x += moveX;
			self.y += moveY;
			// Create dust clouds periodically while moving
			self.dustTimer += gameSpeed;
			if (self.dustTimer >= 15) {
				self.createDustCloud();
				self.dustTimer = 0;
			}
			// Create motion lines for charging effect
			if (LK.ticks % Math.max(1, Math.floor(8 / gameSpeed)) === 0) {
				self.createMotionLine();
			}
		} else {
			// Attack the target (boss deals more damage)
			if (self.currentTarget === crystalTower) {
				crystalTower.takeDamage(40);
				enemyAttacks++;
			} else if (self.currentTarget === hero) {
				// Flash hero red when attacked
				LK.effects.flashObject(hero, 0xff0000, 500);
				// Damage hero
				heroHealth -= 50;
				enemyAttacks++;
				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: Math.floor(1000 / gameSpeed),
						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();
						enemyAttacks++;
						break;
					}
				}
			}
			self.die();
		}
	};
	return self;
});
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 >= Math.floor(self.fireRate / gameSpeed)) {
			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 = Math.floor(160 * difficultyScaling.healthMultiplier);
		self.maxHealth = Math.floor(160 * difficultyScaling.healthMultiplier);
		self.speed = 1.5;
		self.goldValue = 15;
		var graphics = self.attachAsset('goblin', {
			anchorX: 0.5,
			anchorY: 1
		});
	} else if (self.enemyType === 'troll') {
		self.health = Math.floor(400 * difficultyScaling.healthMultiplier);
		self.maxHealth = Math.floor(400 * difficultyScaling.healthMultiplier);
		self.speed = 0.8;
		self.goldValue = 30;
		var graphics = self.attachAsset('troll', {
			anchorX: 0.5,
			anchorY: 1
		});
	} else if (self.enemyType === 'skeleton') {
		self.health = Math.floor(240 * difficultyScaling.healthMultiplier);
		self.maxHealth = Math.floor(240 * difficultyScaling.healthMultiplier);
		self.speed = 1.2 * difficultyScaling.skeletonSpeedMultiplier;
		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 * gameSpeed;
		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 * gameSpeed;
			var moveY = dy / distance * self.speed * gameSpeed;
			self.x += moveX;
			self.y += moveY;
			// Create dust clouds periodically while moving
			self.dustTimer += gameSpeed;
			if (self.dustTimer >= 15) {
				self.createDustCloud();
				self.dustTimer = 0;
			}
			// Create motion lines for charging effect
			if (LK.ticks % Math.max(1, Math.floor(8 / gameSpeed)) === 0) {
				self.createMotionLine();
			}
		} else {
			// Attack the target
			if (self.currentTarget === crystalTower) {
				crystalTower.takeDamage(20);
				enemyAttacks++;
			} else if (self.currentTarget === hero) {
				// Flash hero red when attacked
				LK.effects.flashObject(hero, 0xff0000, 500);
				// Damage hero
				heroHealth -= 25;
				enemyAttacks++;
				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: Math.floor(1000 / gameSpeed),
						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();
						enemyAttacks++;
						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 >= Math.floor(self.fireRate / gameSpeed)) {
			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 * gameSpeed;
			self.y += dy / distance * self.speed * gameSpeed;
		}
	};
	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 >= Math.floor(self.fireRate / gameSpeed)) {
			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 * gameSpeed;
			self.y += dy / distance * self.speed * gameSpeed;
		}
	};
	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;
var enemyAttacks = 0;
var bossActive = false;
var difficultyScaling = {
	healthMultiplier: 1.0,
	skeletonSpeedMultiplier: 1.0
};
// Track enemies in contact with crystal tower for continuous damage
var enemiesInContact = [];
var contactDamageTimer = 0;
// Game speed control
var gameSpeed = 1.0;
var gameSpeedOptions = [1.0, 1.5, 2.0, 3.0, 5.0];
var currentSpeedIndex = 0;
// 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;
// Boss health bar (initially hidden)
var bossHealthBar = LK.getAsset('uiPanel', {
	anchorX: 0.5,
	anchorY: 0.5
});
bossHealthBar.scaleX = 4;
bossHealthBar.scaleY = 0.5;
bossHealthBar.tint = 0x800080;
bossHealthBar.visible = false;
LK.gui.top.addChild(bossHealthBar);
bossHealthBar.x = 0;
bossHealthBar.y = 100;
var bossHealthFill = LK.getAsset('uiPanel', {
	anchorX: 0,
	anchorY: 0.5
});
bossHealthFill.scaleX = 4;
bossHealthFill.scaleY = 0.4;
bossHealthFill.tint = 0xff0000;
bossHealthFill.visible = false;
bossHealthBar.addChild(bossHealthFill);
bossHealthFill.x = -400;
bossHealthFill.y = 0;
var bossHealthText = new Text2('BOSS', {
	size: 40,
	fill: 0xFFFFFF
});
bossHealthText.anchor.set(0.5, 0.5);
bossHealthText.visible = false;
LK.gui.top.addChild(bossHealthText);
bossHealthText.x = 0;
bossHealthText.y = 60;
// 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);
// Game speed button
var speedButton = LK.getAsset('uiPanel', {
	anchorX: 0.5,
	anchorY: 0.5
});
speedButton.x = 150;
speedButton.y = -50;
speedButton.scaleX = 1.2;
speedButton.scaleY = 0.8;
speedButton.tint = 0x4169e1;
LK.gui.bottomLeft.addChild(speedButton);
var speedText = new Text2('Speed: 1.0x', {
	size: 28,
	fill: 0xFFFFFF
});
speedText.anchor.set(0.5, 0.5);
speedButton.addChild(speedText);
// Speed button handler
speedButton.down = function (x, y, obj) {
	currentSpeedIndex = (currentSpeedIndex + 1) % gameSpeedOptions.length;
	gameSpeed = gameSpeedOptions[currentSpeedIndex];
	speedText.setText('Speed: ' + gameSpeed + 'x');
	// Note: Game speed functionality not available in LK engine
};
// 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 (enemies.length === 0) {
		// For boss waves (multiples of 5), just check if all enemies are dead
		// For regular waves, check if we've spawned enough enemies and they're all dead
		if (bossActive || enemiesSpawned >= enemiesInWave) {
			waveComplete = true;
			wave++;
			enemiesInWave += 2;
			enemiesSpawned = 0;
			waveComplete = false;
			bossActive = false; // Reset boss active flag for next wave
			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 () {
	// Check for boss spawn at wave 5 and every multiple of 5 (spawn at start of boss wave)
	if (wave % 5 === 0 && wave >= 5 && !bossActive && enemiesSpawned === 0) {
		// Spawn boss at the beginning of boss waves
		var boss = new Boss();
		// Spawn from random edge
		var side = Math.floor(Math.random() * 4);
		if (side === 0) {
			// Top
			boss.x = Math.random() * 2048;
			boss.y = 0;
		} else if (side === 1) {
			// Right
			boss.x = 2048;
			boss.y = Math.random() * 2732;
		} else if (side === 2) {
			// Bottom
			boss.x = Math.random() * 2048;
			boss.y = 2732;
		} else {
			// Left
			boss.x = 0;
			boss.y = Math.random() * 2732;
		}
		game.addChild(boss);
		enemies.push(boss);
		bossActive = true;
		enemiesSpawned++; // Count boss as spawned enemy
		// Flash screen to indicate boss spawn
		LK.effects.flashScreen(0x800080, 1000);
		// Increase difficulty scaling after each boss round
		difficultyScaling.healthMultiplier += 0.15; // 15% health increase per round
		difficultyScaling.skeletonSpeedMultiplier += 0.08; // 8% speed increase for skeletons per round
	}
	// Spawn regular enemies alongside boss on boss waves, or normally on regular waves
	if (enemiesSpawned < enemiesInWave && !(wave % 5 === 0 && wave >= 5 && enemiesSpawned === 1)) {
		enemySpawnTimer += gameSpeed;
		if (enemySpawnTimer >= 120) {
			// Spawn every 2 seconds
			spawnEnemy();
			enemySpawnTimer = 0;
		}
	}
	// Update health display
	healthText.setText('Tower HP: ' + crystalTower.health);
	// Update boss health bar
	var currentBoss = null;
	for (var i = 0; i < enemies.length; i++) {
		if (enemies[i].health === undefined || enemies[i].maxHealth === undefined) continue;
		if (enemies[i].maxHealth >= 800) {
			// Boss has 800+ max health
			currentBoss = enemies[i];
			break;
		}
	}
	if (currentBoss && bossActive) {
		bossHealthBar.visible = true;
		bossHealthFill.visible = true;
		bossHealthText.visible = true;
		var healthPercent = currentBoss.health / currentBoss.maxHealth;
		bossHealthFill.scaleX = 4 * healthPercent;
		bossHealthText.setText('BOSS - ' + currentBoss.health + '/' + currentBoss.maxHealth);
	} else {
		bossHealthBar.visible = false;
		bossHealthFill.visible = false;
		bossHealthText.visible = false;
	}
	// Check for enemies in contact with crystal tower for continuous damage
	var currentEnemiesInContact = [];
	for (var i = 0; i < enemies.length; i++) {
		var enemy = enemies[i];
		var dx = enemy.x - crystalTower.x;
		var dy = enemy.y - crystalTower.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		if (distance < 80) {
			// Contact threshold
			currentEnemiesInContact.push(enemy);
		}
	}
	// Apply contact damage every second (60 ticks)
	contactDamageTimer += gameSpeed;
	if (contactDamageTimer >= 60 && currentEnemiesInContact.length > 0) {
		crystalTower.takeDamage(2 * currentEnemiesInContact.length);
		contactDamageTimer = 0;
	}
	// Update enemies in contact array
	enemiesInContact = currentEnemiesInContact;
	// 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 % Math.max(1, Math.floor(180 / gameSpeed)) === 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 % Math.max(1, Math.floor(60 / gameSpeed)) === 0) {
		LK.effects.flashScreen(0x8b0000, 200);
	}
	checkWaveComplete();
};

===================================================================
--- original.js
+++ change.js
@@ -7,10 +7,10 @@
 * Classes
 ****/ 
 var Boss = Container.expand(function () {
 	var self = Container.call(this);
-	self.health = Math.floor(800 * difficultyScaling.healthMultiplier);
-	self.maxHealth = Math.floor(800 * difficultyScaling.healthMultiplier);
+	self.health = Math.floor(8000 * difficultyScaling.healthMultiplier);
+	self.maxHealth = Math.floor(8000 * difficultyScaling.healthMultiplier);
 	self.speed = 0.6;
 	self.goldValue = 100;
 	self.currentTarget = null;
 	self.lastX = 0;
@@ -377,28 +377,28 @@
 	self.lastY = 0;
 	self.dustTimer = 0;
 	self.motionEffects = [];
 	if (self.enemyType === 'goblin') {
-		self.health = Math.floor(80 * difficultyScaling.healthMultiplier);
-		self.maxHealth = Math.floor(80 * difficultyScaling.healthMultiplier);
+		self.health = Math.floor(160 * difficultyScaling.healthMultiplier);
+		self.maxHealth = Math.floor(160 * difficultyScaling.healthMultiplier);
 		self.speed = 1.5;
 		self.goldValue = 15;
 		var graphics = self.attachAsset('goblin', {
 			anchorX: 0.5,
 			anchorY: 1
 		});
 	} else if (self.enemyType === 'troll') {
-		self.health = Math.floor(200 * difficultyScaling.healthMultiplier);
-		self.maxHealth = Math.floor(200 * difficultyScaling.healthMultiplier);
+		self.health = Math.floor(400 * difficultyScaling.healthMultiplier);
+		self.maxHealth = Math.floor(400 * difficultyScaling.healthMultiplier);
 		self.speed = 0.8;
 		self.goldValue = 30;
 		var graphics = self.attachAsset('troll', {
 			anchorX: 0.5,
 			anchorY: 1
 		});
 	} else if (self.enemyType === 'skeleton') {
-		self.health = Math.floor(120 * difficultyScaling.healthMultiplier);
-		self.maxHealth = Math.floor(120 * difficultyScaling.healthMultiplier);
+		self.health = Math.floor(240 * difficultyScaling.healthMultiplier);
+		self.maxHealth = Math.floor(240 * difficultyScaling.healthMultiplier);
 		self.speed = 1.2 * difficultyScaling.skeletonSpeedMultiplier;
 		self.goldValue = 20;
 		var graphics = self.attachAsset('skeleton', {
 			anchorX: 0.5,
@@ -1049,8 +1049,11 @@
 var difficultyScaling = {
 	healthMultiplier: 1.0,
 	skeletonSpeedMultiplier: 1.0
 };
+// Track enemies in contact with crystal tower for continuous damage
+var enemiesInContact = [];
+var contactDamageTimer = 0;
 // Game speed control
 var gameSpeed = 1.0;
 var gameSpeedOptions = [1.0, 1.5, 2.0, 3.0, 5.0];
 var currentSpeedIndex = 0;
@@ -1372,8 +1375,28 @@
 		bossHealthBar.visible = false;
 		bossHealthFill.visible = false;
 		bossHealthText.visible = false;
 	}
+	// Check for enemies in contact with crystal tower for continuous damage
+	var currentEnemiesInContact = [];
+	for (var i = 0; i < enemies.length; i++) {
+		var enemy = enemies[i];
+		var dx = enemy.x - crystalTower.x;
+		var dy = enemy.y - crystalTower.y;
+		var distance = Math.sqrt(dx * dx + dy * dy);
+		if (distance < 80) {
+			// Contact threshold
+			currentEnemiesInContact.push(enemy);
+		}
+	}
+	// Apply contact damage every second (60 ticks)
+	contactDamageTimer += gameSpeed;
+	if (contactDamageTimer >= 60 && currentEnemiesInContact.length > 0) {
+		crystalTower.takeDamage(2 * currentEnemiesInContact.length);
+		contactDamageTimer = 0;
+	}
+	// Update enemies in contact array
+	enemiesInContact = currentEnemiesInContact;
 	// Check for hero collecting coins
 	for (var i = goldCoins.length - 1; i >= 0; i--) {
 		var coin = goldCoins[i];
 		var dx = coin.x - hero.x;