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

/**** 
* Classes
****/ 
var Bullet = Container.expand(function () {
	var self = Container.call(this);
	var bulletGraphics = self.attachAsset('bullet', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.velocityX = 0;
	self.velocityY = 0;
	self.damage = 25;
	self.update = function () {
		self.x += self.velocityX;
		self.y += self.velocityY;
		if (self.x < 0 || self.x > 2048 || self.y < 0 || self.y > 2732) {
			self.removeSelf();
		}
		for (var i = 0; i < enemies.length; i++) {
			var enemy = enemies[i];
			if (self.intersects(enemy)) {
				enemy.takeDamage(self.damage);
				self.removeSelf();
				break;
			}
		}
	};
	self.removeSelf = function () {
		var index = bullets.indexOf(self);
		if (index !== -1) {
			bullets.splice(index, 1);
		}
		self.destroy();
	};
	return self;
});
var EnemyBase = Container.expand(function (assetType, health, speed, damage, xpValue) {
	var self = Container.call(this);
	var enemyGraphics = self.attachAsset(assetType, {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.health = health || 20;
	self.maxHealth = self.health;
	self.speed = speed || 1;
	self.damage = damage || 10;
	self.xpValue = xpValue || 3;
	self.lastDamageTime = 0;
	self.baseSpeed = self.speed;
	self.assetType = assetType;
	self.healthBar = null;
	self.needsHealthBar = health > 50; // Big enemies (TankEnemy, ShooterEnemy) get health bars
	self.update = function () {
		self.updateMovement();
		self.checkPlayerCollision();
		if (self.healthBar) {
			self.healthBar.update();
		}
	};
	self.updateMovement = function () {
		var dx = player.x - self.x;
		var dy = player.y - self.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		if (distance > 0) {
			self.x += dx / distance * self.speed;
			self.y += dy / distance * self.speed;
		}
	};
	self.checkPlayerCollision = function () {
		var dx = player.x - self.x;
		var dy = player.y - self.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		if (distance < 40 && LK.ticks - self.lastDamageTime > 60) {
			player.takeDamage(self.damage);
			self.lastDamageTime = LK.ticks;
		}
	};
	self.takeDamage = function (damage) {
		self.health -= damage;
		// Create health bar if this enemy needs one and doesn't have one yet
		if (self.needsHealthBar && !self.healthBar) {
			var barSize = enemyHealthBarSizes[self.assetType] || {
				width: 40,
				height: 6
			};
			self.healthBar = new EnemyHealthBar(self, barSize.width, barSize.height);
			game.addChild(self.healthBar);
		}
		if (self.health <= 0) {
			self.die();
		}
	};
	self.die = function () {
		// Clean up health bar if it exists
		if (self.healthBar) {
			self.healthBar.removeSelf();
			self.healthBar = null;
		}
		for (var i = 0; i < self.xpValue; i++) {
			var xpOrb = new XPOrb();
			xpOrb.x = self.x + (Math.random() - 0.5) * 50;
			xpOrb.y = self.y + (Math.random() - 0.5) * 50;
			xpOrbs.push(xpOrb);
			game.addChild(xpOrb);
		}
		var index = enemies.indexOf(self);
		if (index !== -1) {
			enemies.splice(index, 1);
		}
		self.destroy();
	};
	return self;
});
var TankEnemy = EnemyBase.expand(function () {
	var self = EnemyBase.call(this, 'tankEnemy', 150, 0.6, 20, 8);
	// Increased health to 150 (6 hits to kill)
	return self;
});
var ShooterEnemy = EnemyBase.expand(function () {
	var self = EnemyBase.call(this, 'shooterEnemy', 75, 0.8, 12, 5);
	// Increased health to 75 (3 hits to kill)
	self.shootTimer = 0;
	self.shootRate = 120;
	self.updateMovement = function () {
		var dx = player.x - self.x;
		var dy = player.y - self.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		// Stop moving when close to player and start shooting
		if (distance > 200) {
			if (distance > 0) {
				self.x += dx / distance * self.speed;
				self.y += dy / distance * self.speed;
			}
		} else {
			// Shoot at player
			self.shootTimer++;
			if (self.shootTimer >= self.shootRate) {
				self.shootAtPlayer();
				self.shootTimer = 0;
			}
		}
	};
	self.shootAtPlayer = function () {
		var bullet = new EnemyBullet();
		bullet.x = self.x;
		bullet.y = self.y;
		var dx = player.x - self.x;
		var dy = player.y - self.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		if (distance > 0) {
			bullet.velocityX = dx / distance * 6;
			bullet.velocityY = dy / distance * 6;
			enemyBullets.push(bullet);
			game.addChild(bullet);
		}
	};
	return self;
});
var FastEnemy = EnemyBase.expand(function () {
	var self = EnemyBase.call(this, 'fastEnemy', 10, 2.5, 8, 2);
	return self;
});
var Boss = EnemyBase.expand(function () {
	var self = EnemyBase.call(this, 'boss', 500, 0.5, 30, 50);
	self.maxHealth = 500 + Math.floor((player.level - 1) / 10) * 200; // Scale with boss tier
	self.health = self.maxHealth;
	self.needsHealthBar = true;
	self.attackTimer = 0;
	self.attackPhase = 0;
	self.isCharging = false;
	self.chargeTarget = {
		x: 0,
		y: 0
	};
	// Boss entrance animation
	self.alpha = 0;
	tween(self, {
		alpha: 1
	}, {
		duration: 2000,
		easing: tween.easeOut
	});
	tween(self, {
		scaleX: 1.2,
		scaleY: 1.2
	}, {
		duration: 1000,
		easing: tween.bounceOut,
		onFinish: function onFinish() {
			tween(self, {
				scaleX: 1,
				scaleY: 1
			}, {
				duration: 500
			});
		}
	});
	self.updateMovement = function () {
		if (self.isCharging) return; // Don't move normally when charging
		var dx = player.x - self.x;
		var dy = player.y - self.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		// Keep distance from player but still move towards them slowly
		if (distance > 300) {
			if (distance > 0) {
				self.x += dx / distance * self.speed;
				self.y += dy / distance * self.speed;
			}
		} else if (distance < 200) {
			// Move away if too close
			if (distance > 0) {
				self.x -= dx / distance * self.speed * 0.5;
				self.y -= dy / distance * self.speed * 0.5;
			}
		}
	};
	self.update = function () {
		self.updateMovement();
		self.checkPlayerCollision();
		self.updateAttacks();
		if (self.healthBar) {
			self.healthBar.update();
		}
	};
	self.updateAttacks = function () {
		self.attackTimer++;
		// Cycle through different attack patterns
		if (self.attackTimer >= 180) {
			// 3 seconds
			self.attackPhase = (self.attackPhase + 1) % 3;
			self.performAttack();
			self.attackTimer = 0;
		}
	};
	self.performAttack = function () {
		switch (self.attackPhase) {
			case 0:
				self.spiralAttack();
				break;
			case 1:
				self.chargeAttack();
				break;
			case 2:
				self.burstAttack();
				break;
		}
	};
	self.spiralAttack = function () {
		// Fire bullets in a spiral pattern
		for (var i = 0; i < 8; i++) {
			var angle = i / 8 * Math.PI * 2 + LK.ticks * 0.1;
			var bullet = new EnemyBullet();
			bullet.x = self.x;
			bullet.y = self.y;
			bullet.velocityX = Math.cos(angle) * 4;
			bullet.velocityY = Math.sin(angle) * 4;
			enemyBullets.push(bullet);
			game.addChild(bullet);
		}
		// Visual effect
		tween(self, {
			tint: 0xff4444
		}, {
			duration: 200,
			onFinish: function onFinish() {
				tween(self, {
					tint: 0xffffff
				}, {
					duration: 200
				});
			}
		});
	};
	self.chargeAttack = function () {
		// Charge towards player
		self.isCharging = true;
		self.chargeTarget.x = player.x;
		self.chargeTarget.y = player.y;
		// Visual warning
		tween(self, {
			tint: 0xff0000,
			scaleX: 1.3,
			scaleY: 1.3
		}, {
			duration: 500,
			onFinish: function onFinish() {
				// Perform the charge
				tween(self, {
					x: self.chargeTarget.x,
					y: self.chargeTarget.y
				}, {
					duration: 800,
					easing: tween.easeOut,
					onFinish: function onFinish() {
						self.isCharging = false;
						tween(self, {
							tint: 0xffffff,
							scaleX: 1,
							scaleY: 1
						}, {
							duration: 300
						});
					}
				});
			}
		});
	};
	self.burstAttack = function () {
		// Fire bullets towards player in a burst
		for (var i = 0; i < 12; i++) {
			var bullet = new EnemyBullet();
			bullet.x = self.x;
			bullet.y = self.y;
			var dx = player.x - self.x;
			var dy = player.y - self.y;
			var distance = Math.sqrt(dx * dx + dy * dy);
			var spread = (i - 6) * 0.2; // Spread bullets around target
			if (distance > 0) {
				var angle = Math.atan2(dy, dx) + spread;
				bullet.velocityX = Math.cos(angle) * 5;
				bullet.velocityY = Math.sin(angle) * 5;
				enemyBullets.push(bullet);
				game.addChild(bullet);
			}
		}
	};
	self.die = function () {
		// Boss death animation
		tween(self, {
			alpha: 0,
			scaleX: 2,
			scaleY: 2,
			rotation: Math.PI
		}, {
			duration: 2000,
			easing: tween.easeOut,
			onFinish: function onFinish() {
				// Clean up health bar if it exists
				if (self.healthBar) {
					self.healthBar.removeSelf();
					self.healthBar = null;
				}
				// Drop lots of XP
				for (var i = 0; i < self.xpValue; i++) {
					var xpOrb = new XPOrb();
					xpOrb.x = self.x + (Math.random() - 0.5) * 100;
					xpOrb.y = self.y + (Math.random() - 0.5) * 100;
					xpOrbs.push(xpOrb);
					game.addChild(xpOrb);
				}
				var index = enemies.indexOf(self);
				if (index !== -1) {
					enemies.splice(index, 1);
				}
				// End boss fight
				isBossFight = false;
				self.destroy();
			}
		});
	};
	return self;
});
var BasicEnemy = EnemyBase.expand(function () {
	var self = EnemyBase.call(this, 'enemy', 20, 1, 10, 3);
	return self;
});
var EnemyBullet = Container.expand(function () {
	var self = Container.call(this);
	var bulletGraphics = self.attachAsset('bullet', {
		anchorX: 0.5,
		anchorY: 0.5,
		tint: 0xff0000
	});
	self.velocityX = 0;
	self.velocityY = 0;
	self.damage = 15;
	self.update = function () {
		self.x += self.velocityX;
		self.y += self.velocityY;
		if (self.x < 0 || self.x > 2048 || self.y < 0 || self.y > 2732) {
			self.removeSelf();
		}
		var dx = player.x - self.x;
		var dy = player.y - self.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		if (distance < 30) {
			player.takeDamage(self.damage);
			self.removeSelf();
		}
	};
	self.removeSelf = function () {
		var index = enemyBullets.indexOf(self);
		if (index !== -1) {
			enemyBullets.splice(index, 1);
		}
		self.destroy();
	};
	return self;
});
var EnemyHealthBar = Container.expand(function (enemy, barWidth, barHeight) {
	var self = Container.call(this);
	self.enemy = enemy;
	self.barWidth = barWidth || 40;
	self.barHeight = barHeight || 6;
	self.background = LK.getAsset('enemy', {
		width: self.barWidth,
		height: self.barHeight,
		anchorX: 0.5,
		anchorY: 0.5,
		tint: 0x666666
	});
	self.foreground = LK.getAsset('healthItem', {
		width: self.barWidth,
		height: self.barHeight,
		anchorX: 0.5,
		anchorY: 0.5,
		tint: 0x4CAF50
	});
	self.addChild(self.background);
	self.addChild(self.foreground);
	self.update = function () {
		// Position above enemy
		self.x = self.enemy.x;
		self.y = self.enemy.y - 30;
		// Update health display
		var healthPercent = self.enemy.health / self.enemy.maxHealth;
		self.foreground.width = self.barWidth * healthPercent;
		// Hide if enemy is at full health
		self.visible = healthPercent < 1.0;
	};
	self.removeSelf = function () {
		self.destroy();
	};
	return self;
});
var ExperienceBar = Container.expand(function () {
	var self = Container.call(this);
	self.background = LK.getAsset('enemy', {
		width: 300,
		height: 15,
		anchorX: 0,
		anchorY: 0,
		tint: 0x333333
	});
	self.foreground = LK.getAsset('xp', {
		width: 300,
		height: 15,
		anchorX: 0,
		anchorY: 0,
		tint: 0x9C27B0
	});
	self.addChild(self.background);
	self.addChild(self.foreground);
	self.updateDisplay = function () {
		var xpPercent = player.experience / player.experienceToNext;
		self.foreground.width = 300 * xpPercent;
	};
	return self;
});
var HealthBar = Container.expand(function () {
	var self = Container.call(this);
	self.background = LK.getAsset('enemy', {
		width: 200,
		height: 20,
		anchorX: 0,
		anchorY: 0,
		tint: 0x333333
	});
	self.foreground = LK.getAsset('player', {
		width: 200,
		height: 20,
		anchorX: 0,
		anchorY: 0,
		tint: 0x4CAF50
	});
	self.addChild(self.background);
	self.addChild(self.foreground);
	self.updateDisplay = function () {
		var healthPercent = player.health / player.maxHealth;
		self.foreground.width = 200 * healthPercent;
	};
	return self;
});
var Player = Container.expand(function () {
	var self = Container.call(this);
	var playerGraphics = self.attachAsset('player', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.health = 100;
	self.maxHealth = 100;
	self.speed = 3;
	self.fireRate = 30;
	self.fireTimer = 0;
	self.experience = 0;
	self.level = 1;
	self.experienceToNext = 10;
	self.update = function () {
		self.fireTimer++;
		if (self.fireTimer >= self.fireRate) {
			self.fireAtNearestEnemy();
			self.fireTimer = 0;
		}
	};
	self.fireAtNearestEnemy = function () {
		var nearestEnemy = null;
		var nearestDistance = Infinity;
		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 < nearestDistance && distance < 400) {
				nearestDistance = distance;
				nearestEnemy = enemy;
			}
		}
		if (nearestEnemy) {
			var bullet = new Bullet();
			bullet.x = self.x;
			bullet.y = self.y;
			var dx = nearestEnemy.x - self.x;
			var dy = nearestEnemy.y - self.y;
			var distance = Math.sqrt(dx * dx + dy * dy);
			bullet.velocityX = dx / distance * 8;
			bullet.velocityY = dy / distance * 8;
			bullets.push(bullet);
			game.addChild(bullet);
			LK.getSound('shoot').play();
		}
	};
	self.takeDamage = function (damage) {
		self.health -= damage;
		if (self.health <= 0) {
			self.health = 0;
			LK.showGameOver();
		}
		healthBar.updateDisplay();
	};
	self.gainExperience = function (amount) {
		self.experience += amount;
		experienceBar.updateDisplay();
		if (self.experience >= self.experienceToNext) {
			self.levelUp();
		}
	};
	self.levelUp = function () {
		if (self.level >= 50) {
			// At max level, just reset experience but don't level up
			self.experience = 0;
			experienceBar.updateDisplay();
			return;
		}
		self.level++;
		self.experience = 0;
		self.experienceToNext = Math.floor(self.experienceToNext * 1.5);
		experienceBar.updateDisplay();
		levelText.setText('Level: ' + self.level);
		// Check for boss fight every 10 levels
		if (self.level % 10 === 0 && !isBossFight) {
			spawnBoss();
		} else {
			// Increase enemy speed based on player level (only if not boss fight)
			for (var i = 0; i < enemies.length; i++) {
				var levelFactor = 1 + (self.level - 1) * 0.1;
				enemies[i].speed = enemies[i].baseSpeed * levelFactor;
			}
		}
		LK.getSound('levelUp').play();
		showUpgradeOptions();
	};
	return self;
});
var StatItem = Container.expand(function (type) {
	var self = Container.call(this);
	var itemGraphics = self.attachAsset(type + 'Item', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.type = type;
	self.lifeTime = 0;
	self.update = function () {
		self.lifeTime++;
		if (self.lifeTime > 1800) {
			self.removeSelf();
		}
		var dx = player.x - self.x;
		var dy = player.y - self.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		if (distance < 30) {
			self.applyEffect();
			self.removeSelf();
		}
	};
	self.applyEffect = function () {
		if (self.type === 'health') {
			player.health = Math.min(player.maxHealth, player.health + 25);
			healthBar.updateDisplay();
			LK.getSound('pickup').play();
		} else if (self.type === 'speed') {
			player.speed += 0.5;
			LK.getSound('pickup').play();
		}
	};
	self.removeSelf = function () {
		var index = statItems.indexOf(self);
		if (index !== -1) {
			statItems.splice(index, 1);
		}
		self.destroy();
	};
	return self;
});
var XPOrb = Container.expand(function () {
	var self = Container.call(this);
	var xpGraphics = self.attachAsset('xp', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.value = 1;
	self.update = function () {
		var dx = player.x - self.x;
		var dy = player.y - self.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		if (distance < 100) {
			self.x += dx / distance * 4;
			self.y += dy / distance * 4;
		}
		if (distance < 25) {
			player.gainExperience(self.value);
			LK.getSound('pickup').play();
			self.removeSelf();
		}
	};
	self.removeSelf = function () {
		var index = xpOrbs.indexOf(self);
		if (index !== -1) {
			xpOrbs.splice(index, 1);
		}
		self.destroy();
	};
	return self;
});

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

/**** 
* Game Code
****/ 
var player;
var enemies = [];
var enemyHealthBarSizes = {
	'enemy': {
		width: 40,
		height: 6
	},
	// BasicEnemy
	'fastEnemy': {
		width: 30,
		height: 5
	},
	// FastEnemy  
	'shooterEnemy': {
		width: 35,
		height: 6
	},
	// ShooterEnemy
	'tankEnemy': {
		width: 60,
		height: 8
	} // TankEnemy (big)
};
var bullets = [];
var enemyBullets = [];
var xpOrbs = [];
var statItems = [];
var enemySpawnTimer = 0;
var itemSpawnTimer = 0;
var waveLevel = 1;
var upgradePanel = null;
var healthBar;
var experienceBar;
var levelText;
var hordeSpawnTimer = 0;
var isBossFight = false;
var currentBoss = null;
// Initialize player
player = game.addChild(new Player());
player.x = 1024;
player.y = 1366;
// Initialize UI
healthBar = new HealthBar();
healthBar.x = 50;
healthBar.y = 50;
LK.gui.topLeft.addChild(healthBar);
experienceBar = new ExperienceBar();
experienceBar.x = 50;
experienceBar.y = 80;
LK.gui.topLeft.addChild(experienceBar);
levelText = new Text2('Level: 1', {
	size: 40,
	fill: 0xFFFFFF
});
levelText.anchor.set(0, 0);
levelText.x = 50;
levelText.y = 110;
LK.gui.topLeft.addChild(levelText);
// Movement variables
var dragNode = null;
function showUpgradeOptions() {
	if (upgradePanel) return;
	upgradePanel = LK.getAsset('enemy', {
		width: 800,
		height: 600,
		anchorX: 0.5,
		anchorY: 0.5,
		tint: 0x333333
	});
	upgradePanel.x = 1024;
	upgradePanel.y = 1366;
	LK.gui.center.addChild(upgradePanel);
	var upgrades = [{
		name: 'Extra Health',
		effect: function effect() {
			player.maxHealth += 25;
			player.health += 25;
			healthBar.updateDisplay();
		}
	}, {
		name: 'Faster Fire',
		effect: function effect() {
			player.fireRate = Math.max(10, player.fireRate - 5);
		}
	}, {
		name: 'More Speed',
		effect: function effect() {
			player.speed += 1;
		}
	}, {
		name: 'Bigger Bullets',
		effect: function effect() {/* Visual upgrade */}
	}, {
		name: 'More Damage',
		effect: function effect() {/* Would need bullet damage tracking */}
	}];
	var selectedUpgrades = [];
	for (var i = 0; i < 3; i++) {
		var randomIndex = Math.floor(Math.random() * upgrades.length);
		selectedUpgrades.push(upgrades[randomIndex]);
	}
	for (var i = 0; i < 3; i++) {
		var button = LK.getAsset('player', {
			width: 200,
			height: 80,
			anchorX: 0.5,
			anchorY: 0.5,
			tint: 0x4CAF50
		});
		button.x = -250 + i * 250;
		button.y = 0;
		button.upgradeIndex = i;
		button.upgrade = selectedUpgrades[i];
		button.down = function (x, y, obj) {
			obj.upgrade.effect();
			hideUpgradeOptions();
		};
		upgradePanel.addChild(button);
		var buttonText = new Text2(selectedUpgrades[i].name, {
			size: 24,
			fill: 0xFFFFFF
		});
		buttonText.anchor.set(0.5, 0.5);
		buttonText.x = button.x;
		buttonText.y = button.y;
		upgradePanel.addChild(buttonText);
	}
}
function hideUpgradeOptions() {
	if (upgradePanel) {
		upgradePanel.destroy();
		upgradePanel = null;
	}
}
function spawnEnemy() {
	var enemy;
	var levelFactor = 1 + (player.level - 1) * 0.1;
	// Choose enemy type based on player level
	var rand = Math.random();
	if (player.level < 5) {
		enemy = new BasicEnemy();
	} else if (player.level < 10) {
		if (rand < 0.7) enemy = new BasicEnemy();else enemy = new FastEnemy();
	} else if (player.level < 20) {
		if (rand < 0.5) enemy = new BasicEnemy();else if (rand < 0.8) enemy = new FastEnemy();else enemy = new TankEnemy();
	} else {
		if (rand < 0.3) enemy = new BasicEnemy();else if (rand < 0.55) enemy = new FastEnemy();else if (rand < 0.8) enemy = new TankEnemy();else enemy = new ShooterEnemy();
	}
	// Scale enemy stats with player level
	enemy.speed = enemy.baseSpeed * levelFactor;
	enemy.health = Math.floor(enemy.maxHealth * levelFactor);
	enemy.maxHealth = enemy.health;
	var side = Math.floor(Math.random() * 4);
	switch (side) {
		case 0:
			// Top
			enemy.x = Math.random() * 2048;
			enemy.y = -50;
			break;
		case 1:
			// Right
			enemy.x = 2098;
			enemy.y = Math.random() * 2732;
			break;
		case 2:
			// Bottom
			enemy.x = Math.random() * 2048;
			enemy.y = 2782;
			break;
		case 3:
			// Left
			enemy.x = -50;
			enemy.y = Math.random() * 2732;
			break;
	}
	enemies.push(enemy);
	game.addChild(enemy);
}
function spawnHorde() {
	var hordeSize = Math.min(10, 3 + Math.floor(player.level / 5));
	var enemyType = Math.random() < 0.6 ? BasicEnemy : FastEnemy;
	for (var i = 0; i < hordeSize; i++) {
		var enemy = new enemyType();
		var levelFactor = 1 + (player.level - 1) * 0.1;
		enemy.speed = enemy.baseSpeed * levelFactor;
		enemy.health = Math.floor(enemy.maxHealth * levelFactor);
		enemy.maxHealth = enemy.health;
		// Spawn all enemies from the same side
		var side = Math.floor(Math.random() * 4);
		var offset = i * 80;
		switch (side) {
			case 0:
				enemy.x = (Math.random() * 1000 + 500 + offset) % 2048;
				enemy.y = -50;
				break;
			case 1:
				enemy.x = 2098;
				enemy.y = (Math.random() * 1000 + 500 + offset) % 2732;
				break;
			case 2:
				enemy.x = (Math.random() * 1000 + 500 + offset) % 2048;
				enemy.y = 2782;
				break;
			case 3:
				enemy.x = -50;
				enemy.y = (Math.random() * 1000 + 500 + offset) % 2732;
				break;
		}
		enemies.push(enemy);
		game.addChild(enemy);
	}
}
function spawnBoss() {
	// Clear all existing enemies
	for (var i = enemies.length - 1; i >= 0; i--) {
		enemies[i].destroy();
		enemies.splice(i, 1);
	}
	// Clear all enemy bullets
	for (var i = enemyBullets.length - 1; i >= 0; i--) {
		enemyBullets[i].destroy();
		enemyBullets.splice(i, 1);
	}
	isBossFight = true;
	currentBoss = new Boss();
	currentBoss.x = 1024; // Center X
	currentBoss.y = 400; // Top area
	enemies.push(currentBoss);
	game.addChild(currentBoss);
}
function spawnStatItem() {
	var item = new StatItem(Math.random() < 0.5 ? 'health' : 'speed');
	item.x = Math.random() * 1800 + 100;
	item.y = Math.random() * 2400 + 100;
	statItems.push(item);
	game.addChild(item);
}
game.move = function (x, y, obj) {
	if (dragNode && !upgradePanel) {
		dragNode.x = x;
		dragNode.y = y;
		// Keep player within bounds
		dragNode.x = Math.max(30, Math.min(2018, dragNode.x));
		dragNode.y = Math.max(30, Math.min(2702, dragNode.y));
	}
};
game.down = function (x, y, obj) {
	if (!upgradePanel) {
		dragNode = player;
	}
};
game.up = function (x, y, obj) {
	dragNode = null;
};
game.update = function () {
	if (upgradePanel) return;
	// Don't spawn regular enemies during boss fights
	if (!isBossFight) {
		// Spawn enemies with increased frequency based on player level
		enemySpawnTimer++;
		var baseSpawnRate = Math.max(30, 180 - waveLevel * 10);
		var levelSpawnBonus = Math.floor(player.level / 5);
		var spawnRate = Math.max(15, baseSpawnRate - levelSpawnBonus * 5);
		if (enemySpawnTimer >= spawnRate) {
			// Higher chance of multiple spawns at higher levels
			var spawnCount = 1;
			if (player.level > 10 && Math.random() < 0.3) spawnCount = 2;
			if (player.level > 20 && Math.random() < 0.2) spawnCount = 3;
			for (var s = 0; s < spawnCount; s++) {
				spawnEnemy();
			}
			enemySpawnTimer = 0;
		}
		// Spawn hordes periodically when player gets stronger
		hordeSpawnTimer++;
		var hordeRate = Math.max(600, 1800 - player.level * 20);
		if (hordeSpawnTimer >= hordeRate && player.level >= 5) {
			spawnHorde();
			hordeSpawnTimer = 0;
		}
	}
	// Spawn stat items
	itemSpawnTimer++;
	if (itemSpawnTimer >= 600) {
		spawnStatItem();
		itemSpawnTimer = 0;
	}
	// Increase difficulty over time
	if (LK.ticks % 1800 === 0) {
		waveLevel++;
	}
	// Update all game objects
	for (var i = enemies.length - 1; i >= 0; i--) {
		enemies[i].update();
	}
	for (var i = bullets.length - 1; i >= 0; i--) {
		bullets[i].update();
	}
	for (var i = enemyBullets.length - 1; i >= 0; i--) {
		enemyBullets[i].update();
	}
	for (var i = xpOrbs.length - 1; i >= 0; i--) {
		xpOrbs[i].update();
	}
	for (var i = statItems.length - 1; i >= 0; i--) {
		statItems[i].update();
	}
	player.update();
};

===================================================================
--- original.js
+++ change.js
@@ -600,12 +600,13 @@
 	self.applyEffect = function () {
 		if (self.type === 'health') {
 			player.health = Math.min(player.maxHealth, player.health + 25);
 			healthBar.updateDisplay();
+			LK.getSound('pickup').play();
 		} else if (self.type === 'speed') {
 			player.speed += 0.5;
+			LK.getSound('pickup').play();
 		}
-		LK.getSound('pickup').play();
 	};
 	self.removeSelf = function () {
 		var index = statItems.indexOf(self);
 		if (index !== -1) {