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

/**** 
* Classes
****/ 
var Boss = Container.expand(function () {
	var self = Container.call(this);
	var graphics = self.attachAsset('boss', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.health = 20 + waveLevel * 5; // Scales with wave level
	self.maxHealth = self.health;
	self.speedX = 2;
	self.speedY = 1;
	self.shootCooldown = 0;
	self.directionChangeTimer = 0;
	self.invulnerable = 0;
	self.update = function () {
		// Direction change logic
		self.directionChangeTimer--;
		if (self.directionChangeTimer <= 0) {
			self.speedX = (Math.random() - 0.5) * 4; // Random horizontal movement
			self.speedY = Math.random() * 2 + 0.5; // Slow downward movement
			self.directionChangeTimer = 60 + Math.random() * 120; // 1-3 seconds
		}
		// Movement with screen bounds checking
		self.x += self.speedX;
		self.y += self.speedY;
		// Keep boss on screen horizontally
		if (self.x < 100) {
			self.x = 100;
			self.speedX = Math.abs(self.speedX);
		}
		if (self.x > 1948) {
			self.x = 1948;
			self.speedX = -Math.abs(self.speedX);
		}
		// Keep boss in upper portion of screen
		if (self.y < 100) {
			self.y = 100;
			self.speedY = Math.abs(self.speedY);
		}
		if (self.y > 800) {
			self.y = 800;
			self.speedY = -Math.abs(self.speedY);
		}
		// Shooting behavior
		self.shootCooldown--;
		if (self.shootCooldown <= 0) {
			self.shoot();
			self.shootCooldown = 90 + Math.random() * 60; // 1.5-2.5 seconds
		}
		// Invulnerability flashing
		if (self.invulnerable > 0) {
			self.invulnerable--;
			graphics.alpha = self.invulnerable % 8 < 4 ? 0.3 : 1.0;
		} else {
			graphics.alpha = 1.0;
		}
		// Health-based tint
		var healthRatio = self.health / self.maxHealth;
		if (healthRatio < 0.3) {
			graphics.tint = 0xff4444; // Red when low health
		} else if (healthRatio < 0.6) {
			graphics.tint = 0xffaa44; // Orange when medium health
		} else {
			graphics.tint = 0xffffff; // White when healthy
		}
	};
	self.shoot = function () {
		// Create multiple bullets in a spread pattern
		var bulletCount = 3 + Math.floor(waveLevel / 5); // More bullets at higher waves
		for (var i = 0; i < bulletCount; i++) {
			var bullet = new EnemyBullet();
			bullet.x = self.x + (Math.random() - 0.5) * 40;
			bullet.y = self.y + graphics.height / 2;
			// Aim towards player with some spread
			var dx = player.x - bullet.x;
			var dy = player.y - bullet.y;
			var distance = Math.sqrt(dx * dx + dy * dy);
			var angle = Math.atan2(dy, dx);
			angle += (Math.random() - 0.5) * 0.6; // Add spread
			bullet.speedX = Math.cos(angle) * 4;
			bullet.speedY = Math.sin(angle) * 4;
			enemyBullets.push(bullet);
			game.addChild(bullet);
		}
		LK.getSound('boss_shoot').play();
	};
	self.takeDamage = function () {
		if (self.invulnerable <= 0) {
			self.health--;
			self.invulnerable = 30;
			LK.effects.flashObject(self, 0xff0000, 200);
		}
	};
	return self;
});
var Enemy = Container.expand(function () {
	var self = Container.call(this);
	var graphics = self.attachAsset('enemy', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.speedX = 0;
	self.speedY = 2;
	self.health = 1;
	self.update = function () {
		self.x += self.speedX;
		self.y += self.speedY;
		// Apply isometric movement effect
		self.x += self.speedY * 0.5;
	};
	return self;
});
var EnemyBullet = Container.expand(function () {
	var self = Container.call(this);
	var graphics = self.attachAsset('bullet', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	graphics.tint = 0xff4444; // Red tint for enemy bullets
	self.speedX = 0;
	self.speedY = 4;
	self.update = function () {
		self.x += self.speedX;
		self.y += self.speedY;
	};
	return self;
});
var HomingMissile = Container.expand(function () {
	var self = Container.call(this);
	var graphics = self.attachAsset('missile', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	var thruster = self.attachAsset('missileThrust', {
		anchorX: 0.5,
		anchorY: 0.0
	});
	thruster.x = 0; // Center horizontally on missile
	thruster.y = graphics.height / 2; // Position at missile bottom
	self.target = null;
	self.speed = 6;
	self.turnSpeed = 0.1;
	self.life = 300; // 5 seconds at 60fps
	self.update = function () {
		self.life--;
		if (self.life <= 0) {
			return;
		}
		// Thruster flickering effect
		thruster.scaleX = 0.6 + Math.random() * 0.8;
		thruster.scaleY = 0.6 + Math.random() * 0.8;
		thruster.alpha = 0.6 + Math.random() * 0.4;
		thruster.x = (Math.random() - 0.5) * 4;
		// Find target if we don't have one
		if (!self.target || !self.target.parent) {
			var availableTargets = [];
			// Prioritize boss if active
			if (bossActive && boss && boss.parent) {
				availableTargets.push(boss);
			} else {
				// Collect enemies that are not already targeted by other missiles
				for (var i = 0; i < enemies.length; i++) {
					var enemy = enemies[i];
					var alreadyTargeted = false;
					// Check if this enemy is already targeted by another missile
					for (var m = 0; m < missiles.length; m++) {
						if (missiles[m] !== self && missiles[m].target === enemy) {
							alreadyTargeted = true;
							break;
						}
					}
					if (!alreadyTargeted) {
						availableTargets.push(enemy);
					}
				}
				// If no untargeted enemies available, allow targeting any enemy
				if (availableTargets.length === 0) {
					availableTargets = enemies.slice(); // Copy all enemies
				}
			}
			// Select target
			if (availableTargets.length > 0) {
				var randomIndex = Math.floor(Math.random() * availableTargets.length);
				self.target = availableTargets[randomIndex];
				// Add random pattern properties for approach
				self.patternTime = 0;
				self.patternAmplitude = 50 + Math.random() * 100; // Random curve amplitude
				self.patternFrequency = 0.05 + Math.random() * 0.1; // Random curve frequency
				self.patternOffset = Math.random() * Math.PI * 2; // Random phase offset
			}
		}
		// Move towards target
		if (self.target && self.target.parent) {
			self.patternTime = (self.patternTime || 0) + 1;
			var dx = self.target.x - self.x;
			var dy = self.target.y - self.y;
			var distance = Math.sqrt(dx * dx + dy * dy);
			if (distance > 5) {
				var targetAngle = Math.atan2(dy, dx);
				var currentAngle = Math.atan2(self.speedY || 0, self.speedX || -self.speed);
				// Add random pattern curve to the approach
				var patternCurve = Math.sin(self.patternTime * self.patternFrequency + self.patternOffset) * self.patternAmplitude;
				var perpAngle = targetAngle + Math.PI / 2; // Perpendicular to target direction
				var curveX = Math.cos(perpAngle) * patternCurve / distance;
				var curveY = Math.sin(perpAngle) * patternCurve / distance;
				// Apply curve offset to target direction
				var adjustedTargetX = self.target.x + curveX;
				var adjustedTargetY = self.target.y + curveY;
				var adjustedDx = adjustedTargetX - self.x;
				var adjustedDy = adjustedTargetY - self.y;
				var adjustedTargetAngle = Math.atan2(adjustedDy, adjustedDx);
				// Smooth turning towards adjusted target
				var angleDiff = adjustedTargetAngle - currentAngle;
				if (angleDiff > Math.PI) {
					angleDiff -= Math.PI * 2;
				}
				if (angleDiff < -Math.PI) {
					angleDiff += Math.PI * 2;
				}
				currentAngle += angleDiff * self.turnSpeed;
				self.speedX = Math.cos(currentAngle) * self.speed;
				self.speedY = Math.sin(currentAngle) * self.speed;
				graphics.rotation = currentAngle + Math.PI / 2;
				// Position thruster at missile bottom with correct rotation
				thruster.rotation = graphics.rotation;
				var thrusterDistance = graphics.height / 2;
				thruster.x = Math.cos(graphics.rotation) * thrusterDistance;
				thruster.y = Math.sin(graphics.rotation) * thrusterDistance;
			} else {
				// Close to target, move directly
				self.speedX = dx / distance * self.speed;
				self.speedY = dy / distance * self.speed;
			}
		} else {
			// No target, move up
			if (!self.speedX) {
				self.speedX = 0;
			}
			if (!self.speedY) {
				self.speedY = -self.speed;
			}
		}
		self.x += self.speedX;
		self.y += self.speedY;
	};
	return self;
});
var Player = Container.expand(function () {
	var self = Container.call(this);
	var graphics = self.attachAsset('player', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	var thruster = self.attachAsset('thruster', {
		anchorX: 0.5,
		anchorY: 0.0
	});
	thruster.y = graphics.height / 2;
	self.health = 3;
	self.maxHealth = 3;
	self.shootCooldown = 0;
	self.invulnerable = 0;
	self.skillCooldown = 0;
	self.skillMaxCooldown = 420; // 7 seconds at 60fps
	self.update = function () {
		if (self.shootCooldown > 0) {
			self.shootCooldown--;
		}
		if (self.skillCooldown > 0) {
			self.skillCooldown--;
		}
		if (self.invulnerable > 0) {
			self.invulnerable--;
			graphics.alpha = self.invulnerable % 10 < 5 ? 0.5 : 1.0;
		} else {
			graphics.alpha = 1.0;
		}
		// Thruster flickering effect
		thruster.scaleX = 0.8 + Math.random() * 0.4;
		thruster.scaleY = 0.8 + Math.random() * 0.4;
		thruster.alpha = 0.7 + Math.random() * 0.3;
		thruster.x = (Math.random() - 0.5) * 8;
	};
	self.shoot = function () {
		if (self.shootCooldown <= 0 && bullets.length < 20) {
			var bullet = new PlayerBullet();
			bullet.x = self.x;
			bullet.y = self.y - graphics.height / 2;
			bullets.push(bullet);
			game.addChild(bullet);
			self.shootCooldown = 15;
			LK.getSound('shoot').play();
		}
	};
	self.useSpecialSkill = function () {
		if (self.skillCooldown <= 0 && enemies.length > 0) {
			var missileCount = 4 + Math.floor(Math.random() * 2); // 4-5 missiles
			var baseDelay = 0;
			for (var i = 0; i < missileCount; i++) {
				// Create missile with delay for sequence effect
				LK.setTimeout(function (index) {
					return function () {
						var missile = new HomingMissile();
						// Spread missiles horizontally
						var spreadWidth = 200;
						var xOffset = (index - (missileCount - 1) / 2) * (spreadWidth / (missileCount - 1));
						missile.x = self.x + xOffset;
						missile.y = self.y - graphics.height / 2;
						missiles.push(missile);
						game.addChild(missile);
					};
				}(i), baseDelay + i * 150); // 150ms delay between each missile
			}
			self.skillCooldown = self.skillMaxCooldown;
			LK.effects.flashObject(self, 0x00ffff, 300);
		}
	};
	self.takeDamage = function () {
		if (self.invulnerable <= 0) {
			self.health--;
			self.invulnerable = 120;
			LK.effects.flashObject(self, 0xff0000, 500);
			if (self.health <= 0) {
				LK.showGameOver();
			}
		}
	};
	return self;
});
var PlayerBullet = Container.expand(function () {
	var self = Container.call(this);
	var graphics = self.attachAsset('bullet', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.speed = -8;
	self.update = function () {
		self.y += self.speed;
	};
	return self;
});
var PowerUp = Container.expand(function () {
	var self = Container.call(this);
	var graphics = self.attachAsset('powerup', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.speedY = 3;
	self.bobOffset = Math.random() * Math.PI * 2;
	self.startY = 0;
	self.update = function () {
		self.y += self.speedY;
		// Apply isometric movement effect
		self.x += self.speedY * 0.5;
		// Bobbing animation
		graphics.y = Math.sin(LK.ticks * 0.1 + self.bobOffset) * 10;
	};
	return self;
});

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

/**** 
* Game Code
****/ 
// Game variables
var player;
var enemies = [];
var bullets = [];
var missiles = [];
var powerups = [];
var enemyBullets = [];
var boss = null;
var bossActive = false;
var enemiesKilledInWave = 0;
var enemySpawnTimer = 0;
var powerupSpawnTimer = 0;
var gameSpeed = 1;
var waveLevel = 1;
var lastHealthDisplay = 3;
// Movement variables
var moveLeft = false;
var moveRight = false;
var moveUp = false;
var moveDown = false;
var dragNode = null;
// Performance optimization - object pools
var explosionPool = [];
var fragmentPool = [];
var maxPoolSize = 50;
// Initialize player
player = game.addChild(new Player());
player.x = 1024;
player.y = 2200;
// Score display
var scoreTxt = new Text2('Score: 0', {
	size: 60,
	fill: 0x00FFFF
});
scoreTxt.anchor.set(0, 0);
scoreTxt.x = 120;
scoreTxt.y = 50;
LK.gui.topLeft.addChild(scoreTxt);
// Health display
var healthTxt = new Text2('Health: 3', {
	size: 60,
	fill: 0xFF0000
});
healthTxt.anchor.set(0, 0);
healthTxt.x = 120;
healthTxt.y = 120;
LK.gui.topLeft.addChild(healthTxt);
// Wave display
var waveTxt = new Text2('Wave: 1', {
	size: 60,
	fill: 0xFFFF00
});
waveTxt.anchor.set(1, 0);
LK.gui.topRight.addChild(waveTxt);
// Skill display
var skillTxt = new Text2('Skill: Ready', {
	size: 60,
	fill: 0x00FFFF
});
skillTxt.anchor.set(0.5, 0);
skillTxt.y = 50;
LK.gui.top.addChild(skillTxt);
// Boss test button
var bossTestBtn = new Text2('BOSS TEST', {
	size: 50,
	fill: 0xFF0000
});
bossTestBtn.anchor.set(1, 0);
bossTestBtn.x = -20;
bossTestBtn.y = 200;
LK.gui.topRight.addChild(bossTestBtn);
// Touch controls
game.down = function (x, y, obj) {
	// Check if boss test button was clicked
	var buttonBounds = LK.gui.topRight.toLocal({
		x: x,
		y: y
	});
	if (buttonBounds.x >= bossTestBtn.x - 150 && buttonBounds.x <= bossTestBtn.x + 150 && buttonBounds.y >= bossTestBtn.y && buttonBounds.y <= bossTestBtn.y + 60) {
		// Boss test button clicked - spawn boss and clear everything
		// Clear all enemies
		for (var i = enemies.length - 1; i >= 0; i--) {
			enemies[i].destroy();
			enemies.splice(i, 1);
		}
		// Clear all powerups
		for (var i = powerups.length - 1; i >= 0; i--) {
			powerups[i].destroy();
			powerups.splice(i, 1);
		}
		// Clear all enemy bullets
		for (var i = enemyBullets.length - 1; i >= 0; i--) {
			enemyBullets[i].destroy();
			enemyBullets.splice(i, 1);
		}
		// Spawn boss if not already active
		if (!bossActive) {
			boss = new Boss();
			boss.x = 1024;
			boss.y = 200;
			game.addChild(boss);
			bossActive = true;
			// Boss intro effect
			LK.effects.flashScreen(0x8800ff, 1000);
			var bossTxt = new Text2('BOSS TEST!', {
				size: 150,
				fill: 0xFF0000
			});
			bossTxt.anchor.set(0.5, 0.5);
			bossTxt.x = 1024;
			bossTxt.y = 1366;
			bossTxt.alpha = 0;
			bossTxt.scaleX = 0.1;
			bossTxt.scaleY = 0.1;
			game.addChild(bossTxt);
			tween(bossTxt, {
				alpha: 1,
				scaleX: 1,
				scaleY: 1
			}, {
				duration: 800,
				easing: tween.elasticOut,
				onFinish: function onFinish() {
					tween(bossTxt, {
						alpha: 0,
						scaleX: 1.5,
						scaleY: 1.5
					}, {
						duration: 1000,
						easing: tween.easeIn,
						onFinish: function onFinish() {
							if (bossTxt.parent) {
								bossTxt.destroy();
							}
						}
					});
				}
			});
		}
		return;
	}
	dragNode = true;
	player.shoot();
	handleMove(x, y, obj);
};
game.up = function (x, y, obj) {
	dragNode = null;
};
function handleMove(x, y, obj) {
	if (dragNode) {
		// Convert screen coordinates to game coordinates
		var gamePos = game.toLocal({
			x: x,
			y: y
		});
		// Smooth movement towards touch position
		var targetX = Math.max(100, Math.min(1948, gamePos.x));
		var targetY = Math.max(200, Math.min(2600, gamePos.y));
		var dx = targetX - player.x;
		var dy = targetY - player.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		if (distance > 20) {
			var speed = 8;
			player.x += dx / distance * speed;
			player.y += dy / distance * speed;
		}
	}
}
game.move = handleMove;
// Spawn enemy function
function spawnEnemy() {
	var enemy = new Enemy();
	// Random spawn position from edges with isometric consideration
	var side = Math.floor(Math.random() * 4);
	switch (side) {
		case 0:
			// Top
			enemy.x = Math.random() * 2048;
			enemy.y = -50;
			enemy.speedY = 2 + Math.random() * 2;
			break;
		case 1:
			// Right
			enemy.x = 2098;
			enemy.y = Math.random() * 1000;
			enemy.speedX = -2 - Math.random() * 2;
			enemy.speedY = 1 + Math.random();
			break;
		case 2:
			// Left
			enemy.x = -50;
			enemy.y = Math.random() * 1000;
			enemy.speedX = 2 + Math.random() * 2;
			enemy.speedY = 1 + Math.random();
			break;
		case 3:
			// Top-left diagonal (isometric style)
			enemy.x = -50;
			enemy.y = -50;
			enemy.speedX = 3 + Math.random() * 2;
			enemy.speedY = 3 + Math.random() * 2;
			break;
	}
	// Apply game speed multiplier
	enemy.speedX *= gameSpeed;
	enemy.speedY *= gameSpeed;
	enemies.push(enemy);
	game.addChild(enemy);
}
// Spawn powerup function
function spawnPowerup() {
	var powerup = new PowerUp();
	powerup.x = Math.random() * 1800 + 124;
	powerup.y = -50;
	powerup.startY = powerup.y;
	powerups.push(powerup);
	game.addChild(powerup);
}
// Optimized explosion function with pooling
function createExplosion(x, y, count, scale, duration) {
	count = Math.min(count || 5, 8); // Limit explosion count
	for (var i = 0; i < count; i++) {
		var explosion;
		if (explosionPool.length > 0) {
			explosion = explosionPool.pop();
			explosion.alpha = 1;
			explosion.scaleX = scale || 0.4;
			explosion.scaleY = scale || 0.4;
			explosion.rotation = 0;
		} else {
			explosion = LK.getAsset('explosion', {
				anchorX: 0.5,
				anchorY: 0.5,
				scaleX: scale || 0.4,
				scaleY: scale || 0.4
			});
		}
		explosion.x = x + (Math.random() - 0.5) * 40;
		explosion.y = y + (Math.random() - 0.5) * 40;
		game.addChild(explosion);
		var angle = i / count * Math.PI * 2;
		var distance = 30 + Math.random() * 20;
		var targetX = explosion.x + Math.cos(angle) * distance;
		var targetY = explosion.y + Math.sin(angle) * distance;
		tween(explosion, {
			x: targetX,
			y: targetY,
			alpha: 0,
			scaleX: (scale || 0.4) * 1.5,
			scaleY: (scale || 0.4) * 1.5,
			rotation: Math.random() * Math.PI * 2
		}, {
			duration: duration || 400,
			easing: tween.easeOut,
			onFinish: function (exp) {
				return function () {
					if (exp.parent) {
						exp.parent.removeChild(exp);
						if (explosionPool.length < maxPoolSize) {
							explosionPool.push(exp);
						}
					}
				};
			}(explosion)
		});
	}
}
// Optimized fragment function with pooling
function createFragments(x, y, count, assetId, scale) {
	count = Math.min(count || 4, 6); // Limit fragment count
	for (var i = 0; i < count; i++) {
		var fragment;
		if (fragmentPool.length > 0) {
			fragment = fragmentPool.pop();
			fragment.alpha = 1;
			fragment.scaleX = scale || 0.2;
			fragment.scaleY = scale || 0.2;
			fragment.rotation = 0;
		} else {
			fragment = LK.getAsset(assetId || 'enemy', {
				anchorX: 0.5,
				anchorY: 0.5,
				scaleX: scale || 0.2,
				scaleY: scale || 0.2
			});
		}
		fragment.x = x + (Math.random() - 0.5) * 20;
		fragment.y = y + (Math.random() - 0.5) * 20;
		game.addChild(fragment);
		var angle = i / count * Math.PI * 2;
		var distance = 40 + Math.random() * 30;
		var targetX = fragment.x + Math.cos(angle) * distance;
		var targetY = fragment.y + Math.sin(angle) * distance;
		tween(fragment, {
			x: targetX,
			y: targetY,
			alpha: 0,
			rotation: Math.random() * Math.PI * 2
		}, {
			duration: 400,
			easing: tween.easeOut,
			onFinish: function (frag) {
				return function () {
					if (frag.parent) {
						frag.parent.removeChild(frag);
						if (fragmentPool.length < maxPoolSize) {
							fragmentPool.push(frag);
						}
					}
				};
			}(fragment)
		});
	}
}
// Main game update
game.update = function () {
	// Auto-shoot
	if (LK.ticks % 20 === 0) {
		player.shoot();
	}
	// Auto-use special skill
	if (player.skillCooldown <= 0 && enemies.length > 0) {
		player.useSpecialSkill();
	}
	// Update skill display
	if (player.skillCooldown > 0) {
		skillTxt.setText('Skill: ' + Math.ceil(player.skillCooldown / 60) + 's');
		skillTxt.fill = 0x888888;
	} else {
		skillTxt.setText('Skill: Ready');
		skillTxt.fill = 0x00FFFF;
	}
	// Boss spawning logic for waves divisible by 5
	if (waveLevel % 5 === 0 && !bossActive && enemies.length === 0) {
		// Kill all remaining enemies and spawn boss
		for (var i = enemies.length - 1; i >= 0; i--) {
			enemies[i].destroy();
			enemies.splice(i, 1);
		}
		// Spawn boss
		boss = new Boss();
		boss.x = 1024;
		boss.y = 200;
		game.addChild(boss);
		bossActive = true;
		enemiesKilledInWave = 0;
		// Boss intro effect
		LK.effects.flashScreen(0x8800ff, 1000);
		var bossTxt = new Text2('BOSS WAVE!', {
			size: 150,
			fill: 0xFF0000
		});
		bossTxt.anchor.set(0.5, 0.5);
		bossTxt.x = 1024;
		bossTxt.y = 1366;
		bossTxt.alpha = 0;
		bossTxt.scaleX = 0.1;
		bossTxt.scaleY = 0.1;
		game.addChild(bossTxt);
		tween(bossTxt, {
			alpha: 1,
			scaleX: 1,
			scaleY: 1
		}, {
			duration: 800,
			easing: tween.elasticOut,
			onFinish: function onFinish() {
				tween(bossTxt, {
					alpha: 0,
					scaleX: 1.5,
					scaleY: 1.5
				}, {
					duration: 1000,
					easing: tween.easeIn,
					onFinish: function onFinish() {
						if (bossTxt.parent) {
							bossTxt.destroy();
						}
					}
				});
			}
		});
	} else if (!bossActive) {
		// Normal enemy spawning
		enemySpawnTimer++;
		var spawnRate = Math.max(30 - Math.floor(waveLevel * 2), 10);
		if (enemySpawnTimer >= spawnRate && enemies.length < 15) {
			spawnEnemy();
			enemySpawnTimer = 0;
		}
	}
	// Powerup spawning
	powerupSpawnTimer++;
	if (powerupSpawnTimer >= 600) {
		// Every 10 seconds
		spawnPowerup();
		powerupSpawnTimer = 0;
	}
	// Update bullets
	for (var i = bullets.length - 1; i >= 0; i--) {
		var bullet = bullets[i];
		if (bullet.lastY === undefined) {
			bullet.lastY = bullet.y;
		}
		// Remove bullets that go off screen (expanded bounds check)
		if (bullet.y < -100 || bullet.y > 2800 || bullet.x < -100 || bullet.x > 2148) {
			bullet.destroy();
			bullets.splice(i, 1);
			continue;
		}
		// Check bullet-enemy collisions
		var hitEnemy = false;
		for (var j = enemies.length - 1; j >= 0; j--) {
			if (bullet.intersects(enemies[j])) {
				// Enemy hit
				LK.setScore(LK.getScore() + 10);
				scoreTxt.setText('Score: ' + LK.getScore());
				enemiesKilledInWave++;
				// Create optimized effects
				var enemy = enemies[j];
				createFragments(enemy.x, enemy.y, 4, 'enemy', 0.2);
				enemy.destroy();
				enemies.splice(j, 1);
				// Destroy bullet
				bullet.destroy();
				bullets.splice(i, 1);
				LK.getSound('hit').play();
				hitEnemy = true;
				break;
			}
		}
		// Check bullet-boss collision
		if (bossActive && boss && bullet.intersects(boss)) {
			boss.takeDamage();
			LK.setScore(LK.getScore() + 5);
			scoreTxt.setText('Score: ' + LK.getScore());
			bullet.destroy();
			bullets.splice(i, 1);
			LK.getSound('hit').play();
			hitEnemy = true;
			// Check if boss is dead
			if (boss.health <= 0) {
				// Boss death effect
				createExplosion(boss.x, boss.y, 8, 0.6, 600);
				LK.setScore(LK.getScore() + 500);
				scoreTxt.setText('Score: ' + LK.getScore());
				boss.destroy();
				boss = null;
				bossActive = false;
				// Spawn powerups after boss defeat
				for (var p = 0; p < 3; p++) {
					var powerup = new PowerUp();
					powerup.x = 1024 + (Math.random() - 0.5) * 400;
					powerup.y = 400 + p * 100;
					powerups.push(powerup);
					game.addChild(powerup);
				}
			}
		}
		if (!hitEnemy) {
			bullet.lastY = bullet.y;
		}
	}
	// Update missiles
	for (var i = missiles.length - 1; i >= 0; i--) {
		var missile = missiles[i];
		// Remove missiles that expire or go off screen
		if (missile.life <= 0 || missile.y < -100 || missile.y > 2800 || missile.x < -100 || missile.x > 2148) {
			// Create optimized explosion effect
			createExplosion(missile.x, missile.y, 4, 0.3, 300);
			missile.destroy();
			missiles.splice(i, 1);
			continue;
		}
		// Check missile-enemy collisions
		for (var j = enemies.length - 1; j >= 0; j--) {
			if (missile.intersects(enemies[j])) {
				// Enemy hit by missile
				LK.setScore(LK.getScore() + 15);
				scoreTxt.setText('Score: ' + LK.getScore());
				enemiesKilledInWave++;
				// Create optimized explosion and fragment effects
				var enemy = enemies[j];
				createExplosion(missile.x, missile.y, 5, 0.4, 400);
				createFragments(enemy.x, enemy.y, 4, 'enemy', 0.15);
				enemy.destroy();
				enemies.splice(j, 1);
				missile.destroy();
				missiles.splice(i, 1);
				LK.getSound('hit').play();
				break;
			}
		}
		// Check missile-boss collision
		if (bossActive && boss && missile.intersects(boss)) {
			boss.takeDamage();
			LK.setScore(LK.getScore() + 10);
			scoreTxt.setText('Score: ' + LK.getScore());
			// Create explosion effect
			var explosionCount = 8;
			for (var e = 0; e < explosionCount; e++) {
				var explosion = LK.getAsset('explosion', {
					anchorX: 0.5,
					anchorY: 0.5,
					scaleX: 0.5,
					scaleY: 0.5
				});
				explosion.x = missile.x + (Math.random() - 0.5) * 50;
				explosion.y = missile.y + (Math.random() - 0.5) * 50;
				game.addChild(explosion);
				var angle = e / explosionCount * Math.PI * 2;
				var distance = 60 + Math.random() * 50;
				var targetX = explosion.x + Math.cos(angle) * distance;
				var targetY = explosion.y + Math.sin(angle) * distance;
				tween(explosion, {
					x: targetX,
					y: targetY,
					alpha: 0,
					scaleX: 1.0,
					scaleY: 1.0,
					rotation: Math.random() * Math.PI * 2
				}, {
					duration: 600,
					easing: tween.easeOut,
					onFinish: function onFinish() {
						if (explosion.parent) {
							explosion.destroy();
						}
					}
				});
			}
			missile.destroy();
			missiles.splice(i, 1);
			LK.getSound('hit').play();
			// Check if boss is dead
			if (boss.health <= 0) {
				// Boss death effect
				var explosionCount = 12;
				for (var e = 0; e < explosionCount; e++) {
					var explosion = LK.getAsset('explosion', {
						anchorX: 0.5,
						anchorY: 0.5,
						scaleX: 0.6,
						scaleY: 0.6
					});
					explosion.x = boss.x + (Math.random() - 0.5) * 100;
					explosion.y = boss.y + (Math.random() - 0.5) * 100;
					game.addChild(explosion);
					var angle = e / explosionCount * Math.PI * 2;
					var distance = 80 + Math.random() * 60;
					var targetX = explosion.x + Math.cos(angle) * distance;
					var targetY = explosion.y + Math.sin(angle) * distance;
					tween(explosion, {
						x: targetX,
						y: targetY,
						alpha: 0,
						scaleX: 1.2,
						scaleY: 1.2,
						rotation: Math.random() * Math.PI * 2
					}, {
						duration: 800,
						easing: tween.easeOut,
						onFinish: function onFinish() {
							if (explosion.parent) {
								explosion.destroy();
							}
						}
					});
				}
				LK.setScore(LK.getScore() + 500);
				scoreTxt.setText('Score: ' + LK.getScore());
				boss.destroy();
				boss = null;
				bossActive = false;
				// Spawn powerups after boss defeat
				for (var p = 0; p < 3; p++) {
					var powerup = new PowerUp();
					powerup.x = 1024 + (Math.random() - 0.5) * 400;
					powerup.y = 400 + p * 100;
					powerups.push(powerup);
					game.addChild(powerup);
				}
			}
			break;
		}
	}
	// Update enemies (reduce collision check frequency)
	for (var i = enemies.length - 1; i >= 0; i--) {
		var enemy = enemies[i];
		// Remove enemies that go off screen
		if (enemy.y > 2800 || enemy.x < -100 || enemy.x > 2148) {
			enemy.destroy();
			enemies.splice(i, 1);
			continue;
		}
		// Check player-enemy collision (only every 3rd frame for performance)
		if (LK.ticks % 3 === 0 && enemy.intersects(player)) {
			player.takeDamage();
			// Create optimized fragmentation effect
			createFragments(enemy.x, enemy.y, 4, 'enemy', 0.2);
			enemy.destroy();
			enemies.splice(i, 1);
		}
	}
	// Update enemy bullets
	for (var i = enemyBullets.length - 1; i >= 0; i--) {
		var enemyBullet = enemyBullets[i];
		// Remove bullets that go off screen
		if (enemyBullet.y > 2800 || enemyBullet.x < -100 || enemyBullet.x > 2148 || enemyBullet.y < -100) {
			enemyBullet.destroy();
			enemyBullets.splice(i, 1);
			continue;
		}
		// Check enemy bullet-player collision
		if (enemyBullet.intersects(player)) {
			player.takeDamage();
			enemyBullet.destroy();
			enemyBullets.splice(i, 1);
		}
	}
	// Update boss if active
	if (bossActive && boss) {
		// Check boss-player collision
		if (boss.intersects(player)) {
			player.takeDamage();
		}
	}
	// Update powerups
	for (var i = powerups.length - 1; i >= 0; i--) {
		var powerup = powerups[i];
		// Remove powerups that go off screen
		if (powerup.y > 2800) {
			powerup.destroy();
			powerups.splice(i, 1);
			continue;
		}
		// Check player-powerup collision
		if (powerup.intersects(player)) {
			player.health = Math.min(player.health + 1, player.maxHealth);
			LK.getSound('powerup').play();
			LK.effects.flashObject(player, 0x00ff00, 300);
			powerup.destroy();
			powerups.splice(i, 1);
		}
	}
	// Update health display
	if (player.health !== lastHealthDisplay) {
		healthTxt.setText('Health: ' + player.health);
		lastHealthDisplay = player.health;
	}
	// Increase difficulty over time
	if (LK.ticks % 1800 === 0) {
		// Every 30 seconds
		waveLevel++;
		gameSpeed += 0.1;
		waveTxt.setText('Wave: ' + waveLevel);
		// Create stylish "WAVE COMPLETED" text
		var waveCompletedTxt = new Text2('WAVE COMPLETED', {
			size: 120,
			fill: 0xFFD700
		});
		waveCompletedTxt.anchor.set(0.5, 0.5);
		waveCompletedTxt.x = 1024;
		waveCompletedTxt.y = 1366;
		waveCompletedTxt.alpha = 0;
		waveCompletedTxt.scaleX = 0.1;
		waveCompletedTxt.scaleY = 0.1;
		game.addChild(waveCompletedTxt);
		// Animate the text with a stylish effect
		tween(waveCompletedTxt, {
			alpha: 1,
			scaleX: 1,
			scaleY: 1
		}, {
			duration: 500,
			easing: tween.elasticOut,
			onFinish: function onFinish() {
				// Hold for a moment then fade out
				tween(waveCompletedTxt, {
					alpha: 0,
					scaleX: 1.2,
					scaleY: 1.2
				}, {
					duration: 800,
					easing: tween.easeIn,
					onFinish: function onFinish() {
						if (waveCompletedTxt.parent) {
							waveCompletedTxt.destroy();
						}
					}
				});
			}
		});
	}
};

===================================================================
--- original.js
+++ change.js
@@ -436,10 +436,87 @@
 });
 skillTxt.anchor.set(0.5, 0);
 skillTxt.y = 50;
 LK.gui.top.addChild(skillTxt);
+// Boss test button
+var bossTestBtn = new Text2('BOSS TEST', {
+	size: 50,
+	fill: 0xFF0000
+});
+bossTestBtn.anchor.set(1, 0);
+bossTestBtn.x = -20;
+bossTestBtn.y = 200;
+LK.gui.topRight.addChild(bossTestBtn);
 // Touch controls
 game.down = function (x, y, obj) {
+	// Check if boss test button was clicked
+	var buttonBounds = LK.gui.topRight.toLocal({
+		x: x,
+		y: y
+	});
+	if (buttonBounds.x >= bossTestBtn.x - 150 && buttonBounds.x <= bossTestBtn.x + 150 && buttonBounds.y >= bossTestBtn.y && buttonBounds.y <= bossTestBtn.y + 60) {
+		// Boss test button clicked - spawn boss and clear everything
+		// Clear all enemies
+		for (var i = enemies.length - 1; i >= 0; i--) {
+			enemies[i].destroy();
+			enemies.splice(i, 1);
+		}
+		// Clear all powerups
+		for (var i = powerups.length - 1; i >= 0; i--) {
+			powerups[i].destroy();
+			powerups.splice(i, 1);
+		}
+		// Clear all enemy bullets
+		for (var i = enemyBullets.length - 1; i >= 0; i--) {
+			enemyBullets[i].destroy();
+			enemyBullets.splice(i, 1);
+		}
+		// Spawn boss if not already active
+		if (!bossActive) {
+			boss = new Boss();
+			boss.x = 1024;
+			boss.y = 200;
+			game.addChild(boss);
+			bossActive = true;
+			// Boss intro effect
+			LK.effects.flashScreen(0x8800ff, 1000);
+			var bossTxt = new Text2('BOSS TEST!', {
+				size: 150,
+				fill: 0xFF0000
+			});
+			bossTxt.anchor.set(0.5, 0.5);
+			bossTxt.x = 1024;
+			bossTxt.y = 1366;
+			bossTxt.alpha = 0;
+			bossTxt.scaleX = 0.1;
+			bossTxt.scaleY = 0.1;
+			game.addChild(bossTxt);
+			tween(bossTxt, {
+				alpha: 1,
+				scaleX: 1,
+				scaleY: 1
+			}, {
+				duration: 800,
+				easing: tween.elasticOut,
+				onFinish: function onFinish() {
+					tween(bossTxt, {
+						alpha: 0,
+						scaleX: 1.5,
+						scaleY: 1.5
+					}, {
+						duration: 1000,
+						easing: tween.easeIn,
+						onFinish: function onFinish() {
+							if (bossTxt.parent) {
+								bossTxt.destroy();
+							}
+						}
+					});
+				}
+			});
+		}
+		return;
+	}
 	dragNode = true;
 	player.shoot();
 	handleMove(x, y, obj);
 };