/**** 
* 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
	// Define findNearestTarget method at the top of the class
	self.findNearestTarget = function () {
		var minDist = 999999;
		var tx = self.x;
		var ty = self.y - 200; // Default target ahead of marine
		// Check demons first
		if (demons && demons.length > 0) {
			for (var i = 0; i < demons.length; ++i) {
				var d = demons[i];
				if (!d.dead) {
					var dx = d.x - self.x;
					var dy = d.y - self.y;
					var dist = dx * dx + dy * dy;
					if (dist < minDist) {
						minDist = dist;
						tx = d.x;
						ty = d.y;
					}
				}
			}
		}
		// 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;
				tx = boss.x;
				ty = boss.y;
			}
		}
		return {
			x: tx,
			y: ty,
			distance: Math.sqrt(minDist)
		};
	};
	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 () {
		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--;
		// Flash purple and green when 5 seconds (300 ticks) remaining
		if (self.duration === 300) {
			// Start color transition sequence
			tween(shieldSprite, {
				tint: 0x9b59b6 // Purple
			}, {
				duration: 150,
				onFinish: function onFinish() {
					tween(shieldSprite, {
						tint: 0x2ecc71 // Green
					}, {
						duration: 150,
						onFinish: function onFinish() {
							// Repeat the color cycle until shield expires
							var flashInterval = LK.setInterval(function () {
								tween(shieldSprite, {
									tint: 0x9b59b6 // Purple
								}, {
									duration: 150,
									onFinish: function onFinish() {
										tween(shieldSprite, {
											tint: 0x2ecc71 // Green
										}, {
											duration: 150
										});
									}
								});
							}, 300);
							// Store interval ID on shield for cleanup
							self.flashInterval = flashInterval;
						}
					});
				}
			});
		}
		if (self.duration <= 0) {
			// Clear flash interval if it exists
			if (self.flashInterval) {
				LK.clearInterval(self.flashInterval);
			}
			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
****/ 
// Power-up
// Health pack
// Demon bullet
// Marine bullet
// Boss Demon
// Demon (enemy)
// Marine (player)
// Arena bounds
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;
	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;
						// Destroy shield immediately when hit
						if (game.children[j].flashInterval) {
							LK.clearInterval(game.children[j].flashInterval);
						}
						// Flash shield effect and destroy it
						tween(game.children[j], {
							alpha: 0
						}, {
							duration: 120,
							onFinish: function onFinish(obj) {
								obj.destroy();
							}
						});
						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;
			// Auto-targeting: find nearest enemy
			var target = marine.findNearestTarget();
			var tx = target.x;
			var ty = target.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.18;
					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;
					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 extra bullets a bit
					var offset = (n - (totalBullets - 1) / 2) * 0.12;
					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
@@ -241,50 +241,50 @@
 	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--;
-		// Auto-targeting logic
-		self.findNearestTarget = function () {
-			var minDist = 999999;
-			var tx = self.x;
-			var ty = self.y - 200; // Default target ahead of marine
-			// Check demons first
-			if (demons && demons.length > 0) {
-				for (var i = 0; i < demons.length; ++i) {
-					var d = demons[i];
-					if (!d.dead) {
-						var dx = d.x - self.x;
-						var dy = d.y - self.y;
-						var dist = dx * dx + dy * dy;
-						if (dist < minDist) {
-							minDist = dist;
-							tx = d.x;
-							ty = d.y;
-						}
+	// Define findNearestTarget method at the top of the class
+	self.findNearestTarget = function () {
+		var minDist = 999999;
+		var tx = self.x;
+		var ty = self.y - 200; // Default target ahead of marine
+		// Check demons first
+		if (demons && demons.length > 0) {
+			for (var i = 0; i < demons.length; ++i) {
+				var d = demons[i];
+				if (!d.dead) {
+					var dx = d.x - self.x;
+					var dy = d.y - self.y;
+					var dist = dx * dx + dy * dy;
+					if (dist < minDist) {
+						minDist = dist;
+						tx = d.x;
+						ty = d.y;
 					}
 				}
 			}
-			// 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;
-					tx = boss.x;
-					ty = boss.y;
-				}
+		}
+		// 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;
+				tx = boss.x;
+				ty = boss.y;
 			}
-			return {
-				x: tx,
-				y: ty,
-				distance: Math.sqrt(minDist)
-			};
+		}
+		return {
+			x: tx,
+			y: ty,
+			distance: Math.sqrt(minDist)
 		};
 	};
+	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
@@ -799,9 +799,9 @@
 	if (marine) {
 		marineFireTimer--;
 		if (marineFireTimer <= 0) {
 			marineFireTimer = marine.powered > 0 ? 4 : marineFireRate;
-			// Use marine's target finding method
+			// Auto-targeting: find nearest enemy
 			var target = marine.findNearestTarget();
 			var tx = target.x;
 			var ty = target.y;
 			// Fire