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

/**** 
* Classes
****/ 
// Boss Demon
var Boss = Container.expand(function () {
	var self = Container.call(this);
	var bossSprite = self.attachAsset('boss', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.radius = bossSprite.width * 0.5;
	self.hp = 80;
	self.shootCooldown = 0;
	self.speed = 3.5;
	self.groundSmashTimer = 0; // Add this property to track smash cooldown
	self.update = function () {
		// Move toward marine
		if (marine && !self.dead) {
			var dx = marine.x - self.x;
			var dy = marine.y - self.y;
			var dist = Math.sqrt(dx * dx + dy * dy);
			if (dist > 1) {
				self.x += dx / dist * self.speed;
				self.y += dy / dist * self.speed;
			}
			// Boss ground smash attack every 8 seconds (480 ticks)
			if (typeof self.groundSmashTimer === "undefined") self.groundSmashTimer = 0;
			self.groundSmashTimer++;
			// 3 seconds (180 ticks) before smash, start color warning
			if (self.groundSmashTimer === 300) {
				// Flash red for 1.5 seconds, then orange for 1.5 seconds
				tween(bossSprite, {
					tint: 0xff0000
				}, {
					duration: 90,
					onFinish: function onFinish() {
						tween(bossSprite, {
							tint: 0xffa500
						}, {
							duration: 90,
							onFinish: function onFinish() {
								// Do nothing, color will be reset after smash
							}
						});
					}
				});
			}
			if (self.groundSmashTimer >= 480) {
				self.groundSmashTimer = 0;
				// Visual effect: flash boss and screen
				tween(bossSprite, {
					tint: 0xffffff
				}, {
					duration: 80,
					onFinish: function onFinish() {
						tween(bossSprite, {
							tint: 0x8e44ad
						}, {
							duration: 120
						});
					}
				});
				LK.effects.flashScreen(0xccccff, 200);
				// Damage marine if close to boss (melee range)
				if (marine && !marine.dead && marine.invuln === 0) {
					var smashDist = bossSprite.width * 1.1;
					var mdx = marine.x - self.x;
					var mdy = marine.y - self.y;
					if (mdx * mdx + mdy * mdy < smashDist * smashDist) {
						marine.hp -= 2;
						if (marine.hp < 0) marine.hp = 0;
						marine.invuln = 60;
						marine.flash();
						updateUI();
						if (marine.hp <= 0) {
							// Game over
							gameOver = true;
							LK.effects.flashScreen(0xff0000, 1000);
							LK.showGameOver();
						}
					}
				}
			}
			// Shoot at marine (triple shot)
			if (self.shootCooldown > 0) self.shootCooldown--;else if (dist < 1200) {
				for (var i = -1; i <= 1; i++) {
					var angle = Math.atan2(marine.y - self.y, marine.x - self.x) + i * 0.18;
					var tx = self.x + Math.cos(angle) * 100;
					var ty = self.y + Math.sin(angle) * 100;
					spawnDemonBullet(self.x, self.y, tx, ty, 10);
				}
				self.shootCooldown = 50;
			}
		}
	};
	self.hit = function () {
		self.hp--;
		tween(bossSprite, {
			tint: 0xffffff
		}, {
			duration: 60,
			onFinish: function onFinish() {
				tween(bossSprite, {
					tint: 0x8e44ad
				}, {
					duration: 100
				});
			}
		});
		if (self.hp <= 0) {
			self.dead = true;
			// Spawn a shield at boss position
			var shield = new Shield();
			shield.x = self.x;
			shield.y = self.y;
			game.addChild(shield);
			// Add 50 points to score
			score += 50;
			updateUI();
			// Create visual effect for shield drop
			tween(shield, {
				y: self.y + 20
			}, {
				duration: 60,
				onFinish: function onFinish() {
					tween(shield, {
						y: self.y
					}, {
						duration: 40
					});
				}
			});
			// Fade out boss
			tween(self, {
				alpha: 0
			}, {
				duration: 300,
				onFinish: function onFinish() {
					self.destroy();
				}
			});
		}
	};
	return self;
});
// Demon (Enemy)
var Demon = Container.expand(function () {
	var self = Container.call(this);
	var demonSprite = self.attachAsset('demon', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.radius = demonSprite.width * 0.5;
	self.hp = 1;
	self.shootCooldown = 0;
	self.speed = 4 + Math.random() * 2;
	self.update = function () {
		// Move toward marine
		if (marine && !self.dead) {
			var dx = marine.x - self.x;
			var dy = marine.y - self.y;
			var dist = Math.sqrt(dx * dx + dy * dy);
			if (dist > 1) {
				self.x += dx / dist * self.speed;
				self.y += dy / dist * self.speed;
			}
			// Shoot at marine
			if (self.shootCooldown > 0) self.shootCooldown--;else if (dist < 900) {
				spawnDemonBullet(self.x, self.y, marine.x, marine.y);
				self.shootCooldown = 90 + Math.floor(Math.random() * 30);
			}
		}
	};
	self.hit = function () {
		self.hp--;
		tween(demonSprite, {
			tint: 0xffffff
		}, {
			duration: 60,
			onFinish: function onFinish() {
				tween(demonSprite, {
					tint: 0xc0392b
				}, {
					duration: 100
				});
			}
		});
		if (self.hp <= 0) {
			self.dead = true;
			tween(self, {
				alpha: 0
			}, {
				duration: 200,
				onFinish: function onFinish() {
					self.destroy();
				}
			});
		}
	};
	return self;
});
// Demon Bullet
var DemonBullet = Container.expand(function () {
	var self = Container.call(this);
	var bulletSprite = self.attachAsset('demonBullet', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.radius = bulletSprite.width * 0.5;
	self.speed = 14;
	self.dx = 0;
	self.dy = 1;
	self.update = function () {
		self.x += self.dx * self.speed;
		self.y += self.dy * self.speed;
	};
	return self;
});
// Health Pack
var HealthPack = Container.expand(function () {
	var self = Container.call(this);
	var hpSprite = self.attachAsset('healthPack', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.radius = hpSprite.width * 0.5;
	return self;
});
// Marine (Player)
var Marine = Container.expand(function () {
	var self = Container.call(this);
	var marineSprite = self.attachAsset('marine', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.radius = marineSprite.width * 0.5;
	self.hp = 1;
	self.invuln = 0; // invulnerability frames
	self.powered = 0; // power-up timer
	self.update = function () {
		if (self.invuln > 0) self.invuln--;
		if (self.powered > 0) self.powered--;
	};
	// Flash when hit
	self.flash = function () {
		tween(marineSprite, {
			tint: 0xffffff
		}, {
			duration: 80,
			onFinish: function onFinish() {
				tween(marineSprite, {
					tint: 0x3a9ad9
				}, {
					duration: 120
				});
			}
		});
	};
	return self;
});
// Marine Bullet
var MarineBullet = Container.expand(function () {
	var self = Container.call(this);
	var bulletSprite = self.attachAsset('marineBullet', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.radius = bulletSprite.width * 0.5;
	self.speed = 32;
	self.dx = 0;
	self.dy = -1;
	self.powered = false;
	self.update = function () {
		// Auto-aim toward nearest target
		if (self.homingStrength > 0) {
			// Find closest target (demon or boss)
			var closestTarget = null;
			var minDist = 999999;
			// Check demons
			for (var i = 0; i < demons.length; i++) {
				var d = demons[i];
				if (d.dead) continue;
				var dx = d.x - self.x;
				var dy = d.y - self.y;
				var dist = dx * dx + dy * dy;
				if (dist < minDist) {
					minDist = dist;
					closestTarget = d;
				}
			}
			// Check boss
			if (boss && !boss.dead) {
				var dx = boss.x - self.x;
				var dy = boss.y - self.y;
				var dist = dx * dx + dy * dy;
				if (dist < minDist) {
					minDist = dist;
					closestTarget = boss;
				}
			}
			// Adjust trajectory toward target
			if (closestTarget) {
				var targetDx = closestTarget.x - self.x;
				var targetDy = closestTarget.y - self.y;
				var targetDist = Math.sqrt(targetDx * targetDx + targetDy * targetDy);
				if (targetDist > 0) {
					var targetNormDx = targetDx / targetDist;
					var targetNormDy = targetDy / targetDist;
					// Smoothly adjust direction
					self.dx += (targetNormDx - self.dx) * self.homingStrength;
					self.dy += (targetNormDy - self.dy) * self.homingStrength;
					// Renormalize direction vector
					var mag = Math.sqrt(self.dx * self.dx + self.dy * self.dy);
					self.dx /= mag;
					self.dy /= mag;
				}
			}
		}
		self.x += self.dx * self.speed;
		self.y += self.dy * self.speed;
	};
	return self;
});
// Power Up
var PowerUp = Container.expand(function () {
	var self = Container.call(this);
	var puSprite = self.attachAsset('powerUp', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.radius = puSprite.width * 0.5;
	return self;
});
// Shield (Protection)
var Shield = Container.expand(function () {
	var self = Container.call(this);
	var shieldSprite = self.attachAsset('powerUp', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Use a different tint for the shield
	shieldSprite.tint = 0x3498db;
	self.radius = shieldSprite.width * 1.1;
	self.duration = 600; // 10 seconds
	self.update = function () {
		self.duration--;
		if (self.duration <= 0) {
			tween(self, {
				alpha: 0
			}, {
				duration: 120,
				onFinish: function onFinish() {
					self.destroy();
				}
			});
		}
		// Follow the marine
		if (marine) {
			self.x = marine.x;
			self.y = marine.y;
		}
	};
	return self;
});

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

/**** 
* Game Code
****/ 
// Arena bounds
// Marine (player)
// Demon (enemy)
// Boss Demon
// Marine bullet
// Demon bullet
// Health pack
// Power-up
var ARENA_MARGIN = 80;
var ARENA_LEFT = ARENA_MARGIN;
var ARENA_TOP = 180;
var ARENA_RIGHT = 2048 - ARENA_MARGIN;
var ARENA_BOTTOM = 2732 - ARENA_MARGIN;
// Game state
var marine = null;
var demons = [];
var boss = null;
var marineBullets = [];
var demonBullets = [];
var healthPacks = [];
var powerUps = [];
var shields = [];
var wave = 1;
var waveTimer = 0;
var spawnTimer = 0;
var bossActive = false;
var dragging = false;
var dragOffsetX = 0;
var dragOffsetY = 0;
var lastMoveX = 0;
var lastMoveY = 0;
var score = 0;
var marineFireTimer = 0;
var marineFireRate = 12; // ticks between shots
var marinePowerTimer = 0;
var marineMaxHP = 1;
var gameOver = false;
// UI
var scoreTxt = new Text2('0', {
	size: 120,
	fill: "#fff"
});
scoreTxt.anchor.set(0.5, 0);
LK.gui.top.addChild(scoreTxt);
var hpTxt = new Text2('♥♥♥', {
	size: 90,
	fill: 0xE74C3C
});
hpTxt.anchor.set(0.5, 0);
LK.gui.top.addChild(hpTxt);
hpTxt.y = 120;
hpTxt.x = 2048 / 2;
// Center arena
function centerArenaX() {
	return (ARENA_LEFT + ARENA_RIGHT) / 2;
}
function centerArenaY() {
	return (ARENA_TOP + ARENA_BOTTOM) / 2;
}
// Spawn marine
function spawnMarine() {
	marine = new Marine();
	marine.x = centerArenaX();
	marine.y = ARENA_BOTTOM - 220;
	game.addChild(marine);
}
// Spawn demon
function spawnDemon() {
	var d = new Demon();
	// Spawn at random edge
	var edge = Math.floor(Math.random() * 4);
	if (edge === 0) {
		// top
		d.x = ARENA_LEFT + Math.random() * (ARENA_RIGHT - ARENA_LEFT);
		d.y = ARENA_TOP + 40;
	} else if (edge === 1) {
		// bottom
		d.x = ARENA_LEFT + Math.random() * (ARENA_RIGHT - ARENA_LEFT);
		d.y = ARENA_BOTTOM - 40;
	} else if (edge === 2) {
		// left
		d.x = ARENA_LEFT + 40;
		d.y = ARENA_TOP + Math.random() * (ARENA_BOTTOM - ARENA_TOP);
	} else {
		// right
		d.x = ARENA_RIGHT - 40;
		d.y = ARENA_TOP + Math.random() * (ARENA_BOTTOM - ARENA_TOP);
	}
	demons.push(d);
	game.addChild(d);
}
// Spawn boss
function spawnBoss() {
	boss = new Boss();
	boss.x = centerArenaX();
	boss.y = ARENA_TOP + 200;
	game.addChild(boss);
	bossActive = true;
}
// Spawn marine bullet
function spawnMarineBullet(x, y, dx, dy, powered) {
	var b = new MarineBullet();
	b.x = x;
	b.y = y;
	var mag = Math.sqrt(dx * dx + dy * dy);
	b.dx = dx / mag;
	b.dy = dy / mag;
	b.powered = powered || false;
	b.targetId = null; // Track target for homing bullets
	b.homingStrength = powered ? 0.06 : 0.03; // How strongly bullets curve toward target
	marineBullets.push(b);
	game.addChild(b);
}
// Spawn demon bullet
function spawnDemonBullet(x, y, tx, ty, speed) {
	var b = new DemonBullet();
	b.x = x;
	b.y = y;
	var dx = tx - x;
	var dy = ty - y;
	var mag = Math.sqrt(dx * dx + dy * dy);
	b.dx = dx / mag;
	b.dy = dy / mag;
	if (speed) b.speed = speed;
	demonBullets.push(b);
	game.addChild(b);
}
// Spawn health pack
function spawnHealthPack() {
	var hp = new HealthPack();
	hp.x = ARENA_LEFT + 100 + Math.random() * (ARENA_RIGHT - ARENA_LEFT - 200);
	hp.y = ARENA_TOP + 100 + Math.random() * (ARENA_BOTTOM - ARENA_TOP - 200);
	healthPacks.push(hp);
	game.addChild(hp);
}
// Spawn power up
function spawnPowerUp() {
	var pu = new PowerUp();
	pu.x = ARENA_LEFT + 100 + Math.random() * (ARENA_RIGHT - ARENA_LEFT - 200);
	pu.y = ARENA_TOP + 100 + Math.random() * (ARENA_BOTTOM - ARENA_TOP - 200);
	powerUps.push(pu);
	game.addChild(pu);
}
// Update UI
function updateUI() {
	scoreTxt.setText(score);
	var hpStr = '';
	for (var i = 0; i < marineMaxHP; ++i) {
		hpStr += i < marine.hp ? '♥' : '♡';
	}
	hpTxt.setText(hpStr);
}
// Start game
function startGame() {
	score = 0;
	wave = 1;
	waveTimer = 0;
	spawnTimer = 0;
	bossActive = false;
	marineFireTimer = 0;
	marinePowerTimer = 0;
	gameOver = false;
	// Remove all
	for (var i = 0; i < demons.length; ++i) demons[i].destroy();
	for (var i = 0; i < marineBullets.length; ++i) marineBullets[i].destroy();
	for (var i = 0; i < demonBullets.length; ++i) demonBullets[i].destroy();
	for (var i = 0; i < healthPacks.length; ++i) healthPacks[i].destroy();
	for (var i = 0; i < powerUps.length; ++i) powerUps[i].destroy();
	// Remove any active shields
	for (var i = 0; i < game.children.length; i++) {
		if (game.children[i] instanceof Shield) {
			game.children[i].destroy();
		}
	}
	if (marine) marine.destroy();
	if (boss) boss.destroy();
	demons = [];
	marineBullets = [];
	demonBullets = [];
	healthPacks = [];
	powerUps = [];
	shields = [];
	boss = null;
	spawnMarine();
	updateUI();
}
startGame();
// Touch controls
game.down = function (x, y, obj) {
	if (gameOver) return;
	// Only drag if touch is inside marine
	var dx = x - marine.x;
	var dy = y - marine.y;
	if (dx * dx + dy * dy < marine.radius * marine.radius * 1.2) {
		dragging = true;
		dragOffsetX = marine.x - x;
		dragOffsetY = marine.y - y;
		lastMoveX = x;
		lastMoveY = y;
	}
};
game.up = function (x, y, obj) {
	dragging = false;
};
game.move = function (x, y, obj) {
	if (gameOver) return;
	// Always follow finger/mouse, clamp to arena
	if (marine) {
		var nx = x;
		var ny = y;
		nx = Math.max(ARENA_LEFT + marine.radius, Math.min(ARENA_RIGHT - marine.radius, nx));
		ny = Math.max(ARENA_TOP + marine.radius, Math.min(ARENA_BOTTOM - marine.radius, ny));
		marine.x = nx;
		marine.y = ny;
		lastMoveX = x;
		lastMoveY = y;
	}
};
// Main update loop
game.update = function () {
	if (gameOver) return;
	// Update marine
	if (marine) marine.update();
	// Update demons
	for (var i = demons.length - 1; i >= 0; --i) {
		var d = demons[i];
		d.update();
		if (d.dead) {
			demons.splice(i, 1);
			score += 10;
			updateUI();
			// Chance to drop health or powerup
			if (Math.random() < 0.08) spawnHealthPack();else if (Math.random() < 0.08) spawnPowerUp();
		}
	}
	// Update boss
	if (boss) {
		boss.update();
		if (boss.dead) {
			bossActive = false;
			boss = null;
			// Score is now added in the boss.hit method
			wave++;
			waveTimer = 0;
		}
		// Marine takes damage when touching boss
		if (marine && !marine.dead && marine.invuln === 0 && !boss.dead) {
			var dx = marine.x - boss.x;
			var dy = marine.y - boss.y;
			var r = marine.radius + boss.radius;
			if (dx * dx + dy * dy < r * r) {
				marine.hp--;
				if (marine.hp < 0) marine.hp = 0;
				marine.invuln = 60;
				marine.flash();
				updateUI();
				if (marine.hp <= 0) {
					gameOver = true;
					LK.effects.flashScreen(0xff0000, 1000);
					LK.showGameOver();
				}
			}
		}
	}
	// Update marine bullets
	for (var i = marineBullets.length - 1; i >= 0; --i) {
		var b = marineBullets[i];
		b.update();
		// Remove if out of bounds
		if (b.x < ARENA_LEFT - 60 || b.x > ARENA_RIGHT + 60 || b.y < ARENA_TOP - 60 || b.y > ARENA_BOTTOM + 60) {
			b.destroy();
			marineBullets.splice(i, 1);
			continue;
		}
		// Hit demons
		var hit = false;
		for (var j = demons.length - 1; j >= 0; --j) {
			var d = demons[j];
			var dx = b.x - d.x;
			var dy = b.y - d.y;
			var r = b.radius + d.radius;
			if (dx * dx + dy * dy < r * r) {
				d.hit();
				hit = true;
				break;
			}
		}
		// Hit boss
		if (!hit && boss) {
			var dx = b.x - boss.x;
			var dy = b.y - boss.y;
			var r = b.radius + boss.radius;
			if (dx * dx + dy * dy < r * r) {
				boss.hit();
				hit = true;
			}
		}
		if (hit) {
			b.destroy();
			marineBullets.splice(i, 1);
		}
	}
	// Update demon bullets
	for (var i = demonBullets.length - 1; i >= 0; --i) {
		var b = demonBullets[i];
		b.update();
		// Remove if out of bounds
		if (b.x < ARENA_LEFT - 60 || b.x > ARENA_RIGHT + 60 || b.y < ARENA_TOP - 60 || b.y > ARENA_BOTTOM + 60) {
			b.destroy();
			demonBullets.splice(i, 1);
			continue;
		}
		// Hit marine
		if (marine && marine.invuln === 0) {
			var dx = b.x - marine.x;
			var dy = b.y - marine.y;
			var r = b.radius + marine.radius;
			if (dx * dx + dy * dy < r * r) {
				b.destroy();
				demonBullets.splice(i, 1);
				// Check if a shield is protecting the marine
				var hasShield = false;
				for (var j = 0; j < game.children.length; j++) {
					if (game.children[j] instanceof Shield) {
						hasShield = true;
						// Flash shield effect
						tween(game.children[j], {
							alpha: 0.4
						}, {
							duration: 20,
							onFinish: function onFinish(obj) {
								tween(obj, {
									alpha: 1
								}, {
									duration: 20
								});
							}
						});
						break;
					}
				}
				if (!hasShield) {
					marine.hp--;
					marine.invuln = 60;
					marine.flash();
					updateUI();
					if (marine.hp <= 0) {
						// Game over
						gameOver = true;
						LK.effects.flashScreen(0xff0000, 1000);
						LK.showGameOver();
					}
				}
			}
		}
	}
	// Update health packs
	for (var i = healthPacks.length - 1; i >= 0; --i) {
		var hp = healthPacks[i];
		if (marine) {
			var dx = hp.x - marine.x;
			var dy = hp.y - marine.y;
			var r = hp.radius + marine.radius;
			if (dx * dx + dy * dy < r * r) {
				if (marine.hp < marineMaxHP) {
					marine.hp++;
					updateUI();
				}
				hp.destroy();
				healthPacks.splice(i, 1);
			}
		}
	}
	// Update power ups
	for (var i = powerUps.length - 1; i >= 0; --i) {
		var pu = powerUps[i];
		if (marine) {
			var dx = pu.x - marine.x;
			var dy = pu.y - marine.y;
			var r = pu.radius + marine.radius;
			if (dx * dx + dy * dy < r * r) {
				marine.powered = 360; // 6 seconds
				pu.destroy();
				powerUps.splice(i, 1);
			}
		}
	}
	// Marine auto-fire
	if (marine) {
		marineFireTimer--;
		if (marineFireTimer <= 0) {
			marineFireTimer = marine.powered > 0 ? 4 : marineFireRate;
			// Find any target to initially aim at (bullets will track on their own)
			var tx = marine.x;
			var ty = marine.y - 200; // Default upward if no targets
			var minDist = 999999;
			for (var i = 0; i < demons.length; ++i) {
				var d = demons[i];
				var dx = d.x - marine.x;
				var dy = d.y - marine.y;
				var dist = dx * dx + dy * dy;
				if (dist < minDist) {
					minDist = dist;
					tx = d.x;
					ty = d.y;
				}
			}
			if (boss && !boss.dead) {
				var dx = boss.x - marine.x;
				var dy = boss.y - marine.y;
				var dist = dx * dx + dy * dy;
				if (dist < minDist) {
					minDist = dist;
					tx = boss.x;
					ty = boss.y;
				}
			}
			// Fire
			// Calculate how many bullets to fire based on score
			var extraBullets = Math.floor(score / 100) + Math.floor(score / 1000);
			var totalBullets = 1 + extraBullets;
			if (marine.powered > 0) {
				// Triple shot, but each "bullet" is a triple
				for (var n = 0; n < totalBullets; ++n) {
					var spread = 0.2; // Slightly wider spread since bullets will auto-aim
					var baseAngle = Math.atan2(ty - marine.y, tx - marine.x);
					// Offset each triple shot slightly for extra bullets
					var offset = (n - (totalBullets - 1) / 2) * 0.15;
					for (var i = -1; i <= 1; ++i) {
						var angle = baseAngle + i * spread + offset;
						var dx = Math.cos(angle);
						var dy = Math.sin(angle);
						spawnMarineBullet(marine.x, marine.y, dx, dy, true);
					}
				}
			} else {
				var dx = tx - marine.x;
				var dy = ty - marine.y;
				var baseAngle = Math.atan2(dy, dx);
				for (var n = 0; n < totalBullets; ++n) {
					// Spread out bullets in a wider pattern - they'll home in on targets
					var offset = (n - (totalBullets - 1) / 2) * 0.2;
					var angle = baseAngle + offset;
					var ddx = Math.cos(angle);
					var ddy = Math.sin(angle);
					spawnMarineBullet(marine.x, marine.y, ddx, ddy, false);
				}
			}
		}
	}
	// Wave logic
	if (!bossActive) {
		// Spawn demons
		if (demons.length < Math.min(3 + wave, 8)) {
			spawnTimer--;
			if (spawnTimer <= 0) {
				spawnDemon();
				spawnTimer = 40 + Math.floor(Math.random() * 30);
			}
		}
		// Next wave
		if (demons.length === 0 && !boss && waveTimer > 60) {
			if (wave % 3 === 0) {
				spawnBoss();
			} else {
				wave++;
				waveTimer = 0;
			}
		}
		waveTimer++;
	} else {
		// Wait for boss defeat
		if (boss && boss.dead) {
			bossActive = false;
			boss = null;
			wave++;
			waveTimer = 0;
		}
	}
	// Randomly spawn health packs and powerups
	if (LK.ticks % 420 === 0 && Math.random() < 0.5) {
		spawnHealthPack();
	}
	if (LK.ticks % 600 === 0 && Math.random() < 0.4) {
		spawnPowerUp();
	}
};
// Reset game on game over
LK.on('gameover', function () {
	startGame();
});

===================================================================
--- original.js
+++ change.js
@@ -275,8 +275,53 @@
 	self.dx = 0;
 	self.dy = -1;
 	self.powered = false;
 	self.update = function () {
+		// Auto-aim toward nearest target
+		if (self.homingStrength > 0) {
+			// Find closest target (demon or boss)
+			var closestTarget = null;
+			var minDist = 999999;
+			// Check demons
+			for (var i = 0; i < demons.length; i++) {
+				var d = demons[i];
+				if (d.dead) continue;
+				var dx = d.x - self.x;
+				var dy = d.y - self.y;
+				var dist = dx * dx + dy * dy;
+				if (dist < minDist) {
+					minDist = dist;
+					closestTarget = d;
+				}
+			}
+			// Check boss
+			if (boss && !boss.dead) {
+				var dx = boss.x - self.x;
+				var dy = boss.y - self.y;
+				var dist = dx * dx + dy * dy;
+				if (dist < minDist) {
+					minDist = dist;
+					closestTarget = boss;
+				}
+			}
+			// Adjust trajectory toward target
+			if (closestTarget) {
+				var targetDx = closestTarget.x - self.x;
+				var targetDy = closestTarget.y - self.y;
+				var targetDist = Math.sqrt(targetDx * targetDx + targetDy * targetDy);
+				if (targetDist > 0) {
+					var targetNormDx = targetDx / targetDist;
+					var targetNormDy = targetDy / targetDist;
+					// Smoothly adjust direction
+					self.dx += (targetNormDx - self.dx) * self.homingStrength;
+					self.dy += (targetNormDy - self.dy) * self.homingStrength;
+					// Renormalize direction vector
+					var mag = Math.sqrt(self.dx * self.dx + self.dy * self.dy);
+					self.dx /= mag;
+					self.dy /= mag;
+				}
+			}
+		}
 		self.x += self.dx * self.speed;
 		self.y += self.dy * self.speed;
 	};
 	return self;
@@ -440,8 +485,10 @@
 	var mag = Math.sqrt(dx * dx + dy * dy);
 	b.dx = dx / mag;
 	b.dy = dy / mag;
 	b.powered = powered || false;
+	b.targetId = null; // Track target for homing bullets
+	b.homingStrength = powered ? 0.06 : 0.03; // How strongly bullets curve toward target
 	marineBullets.push(b);
 	game.addChild(b);
 }
 // Spawn demon bullet
@@ -722,11 +769,11 @@
 	if (marine) {
 		marineFireTimer--;
 		if (marineFireTimer <= 0) {
 			marineFireTimer = marine.powered > 0 ? 4 : marineFireRate;
-			// Find nearest demon or boss
-			var tx = marine.x,
-				ty = marine.y - 200;
+			// Find any target to initially aim at (bullets will track on their own)
+			var tx = marine.x;
+			var ty = marine.y - 200; // Default upward if no targets
 			var minDist = 999999;
 			for (var i = 0; i < demons.length; ++i) {
 				var d = demons[i];
 				var dx = d.x - marine.x;
@@ -754,12 +801,12 @@
 			var totalBullets = 1 + extraBullets;
 			if (marine.powered > 0) {
 				// Triple shot, but each "bullet" is a triple
 				for (var n = 0; n < totalBullets; ++n) {
-					var spread = 0.18;
+					var spread = 0.2; // Slightly wider spread since bullets will auto-aim
 					var baseAngle = Math.atan2(ty - marine.y, tx - marine.x);
 					// Offset each triple shot slightly for extra bullets
-					var offset = (n - (totalBullets - 1) / 2) * 0.12;
+					var offset = (n - (totalBullets - 1) / 2) * 0.15;
 					for (var i = -1; i <= 1; ++i) {
 						var angle = baseAngle + i * spread + offset;
 						var dx = Math.cos(angle);
 						var dy = Math.sin(angle);
@@ -770,10 +817,10 @@
 				var dx = tx - marine.x;
 				var dy = ty - marine.y;
 				var baseAngle = Math.atan2(dy, dx);
 				for (var n = 0; n < totalBullets; ++n) {
-					// Spread out extra bullets a bit
-					var offset = (n - (totalBullets - 1) / 2) * 0.12;
+					// Spread out bullets in a wider pattern - they'll home in on targets
+					var offset = (n - (totalBullets - 1) / 2) * 0.2;
 					var angle = baseAngle + offset;
 					var ddx = Math.cos(angle);
 					var ddy = Math.sin(angle);
 					spawnMarineBullet(marine.x, marine.y, ddx, ddy, false);