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

/**** 
* Classes
****/ 
// Aiming line class
var AimLine = Container.expand(function () {
	var self = Container.call(this);
	// Attach aim line asset, anchor at left (0,0.5)
	var lineGfx = self.attachAsset('aimLine', {
		anchorX: 0,
		anchorY: 0.5
	});
	// Set default scale
	lineGfx.scaleY = 0.2; // Thin line
	// Set color, etc. if needed
	return self;
});
// Bullet class
var Bullet = Container.expand(function () {
	var self = Container.call(this);
	// Determine bullet tier based on score at spawn
	var tier = Math.floor(score / 100);
	if (tier >= bulletColors.length) tier = bulletColors.length - 1;
	self.tier = tier;
	// Attach bullet asset, center anchor, color by tier
	var bulletGfx = self.attachAsset('bullet', {
		anchorX: 0.5,
		anchorY: 0.5,
		color: bulletColors[tier]
	});
	// Direction vector (set on spawn)
	self.dx = 0;
	self.dy = 0;
	self.speed = 40 + tier * 2; // px per frame, slight speed bonus per tier
	// Damage increases with tier
	self.damage = 1 + tier;
	self.update = function () {
		// Bullet bounce logic: number of bounces = 1 + floor(score/10)
		if (typeof self.bouncesLeft === "undefined") {
			self.bouncesLeft = 1 + Math.floor(score / 10);
			self.lastHitZombies = [];
		}
		// If bullet just bounced, skip homing for this frame
		if (self.justBounced) {
			self.justBounced = false;
		} else if (zombies && zombies.length > 0) {
			// Home in on closest zombie not already hit
			var minDist = Infinity;
			var closest = null;
			for (var i = 0; i < zombies.length; i++) {
				var z = zombies[i];
				// Don't home to zombies already hit by this bullet
				if (self.lastHitZombies.indexOf(z) !== -1) continue;
				var zx = z.x - self.x;
				var zy = z.y - self.y;
				var d = Math.sqrt(zx * zx + zy * zy);
				if (d < minDist) {
					minDist = d;
					closest = z;
				}
			}
			if (closest && minDist > 1) {
				// Adjust direction toward closest zombie
				var dx = closest.x - self.x;
				var dy = closest.y - self.y;
				var dist = Math.sqrt(dx * dx + dy * dy);
				if (dist > 0) {
					// Smoothly adjust direction (homing)
					var homingStrength = 0.18;
					self.dx = (1 - homingStrength) * self.dx + homingStrength * (dx / dist);
					self.dy = (1 - homingStrength) * self.dy + homingStrength * (dy / dist);
					// Normalize direction
					var norm = Math.sqrt(self.dx * self.dx + self.dy * self.dy);
					if (norm > 0) {
						self.dx /= norm;
						self.dy /= norm;
					}
				}
			}
		}
		// At score >= 210, slow down bullet and instantly bounce to next zombie if possible
		if (score >= 210) {
			// Slow down bullet
			self.speed = Math.max(10, 18 + self.tier * 2);
			// Instantly bounce to next zombie if bounces left and zombies available
			if (typeof self.bouncesLeft === "undefined") {
				self.bouncesLeft = 1 + Math.floor(score / 10);
				self.lastHitZombies = [];
			}
			if (self.bouncesLeft > 0 && zombies && zombies.length > 1) {
				// Find next closest zombie not already hit
				var minDist = Infinity;
				var nextTarget = null;
				for (var zz = 0; zz < zombies.length; zz++) {
					var z2 = zombies[zz];
					if (self.lastHitZombies.indexOf(z2) !== -1) continue;
					var zx = z2.x - self.x;
					var zy = z2.y - self.y;
					var d = Math.sqrt(zx * zx + zy * zy);
					if (d < minDist) {
						minDist = d;
						nextTarget = z2;
					}
				}
				if (nextTarget) {
					// Set direction to next zombie
					var dx = nextTarget.x - self.x;
					var dy = nextTarget.y - self.y;
					var dist = Math.sqrt(dx * dx + dy * dy);
					if (dist > 0) {
						self.dx = dx / dist;
						self.dy = dy / dist;
						self.lastHitZombies.push(nextTarget);
						self.bouncesLeft--;
					}
				}
			}
		}
		self.x += self.dx * self.speed;
		self.y += self.dy * self.speed;
	};
	return self;
});
// Gun/player class
var Gun = Container.expand(function () {
	var self = Container.call(this);
	// Attach gun asset, center anchor
	var gunGfx = self.attachAsset('gun', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// For possible future use: gunGfx
	return self;
});
// Zombie class
var Zombie = Container.expand(function () {
	var self = Container.call(this);
	// Determine zombie tier based on score at spawn
	var tier = Math.floor(score / 100);
	if (tier >= zombieColors.length) tier = zombieColors.length - 1;
	self.tier = tier;
	// Attach zombie asset, center anchor, color by tier
	var zombieGfx = self.attachAsset('zombie', {
		anchorX: 0.5,
		anchorY: 0.5,
		color: zombieColors[tier]
	});
	// Target position (player center)
	self.targetX = 0;
	self.targetY = 0;
	self.speed = 5 + tier * 0.5; // Fixed speed, no randomness
	// Health increases with tier
	self.maxHealth = 1 + tier * 2;
	self.health = self.maxHealth;
	self.update = function () {
		// Move toward target
		var dx = self.targetX - self.x;
		var dy = self.targetY - self.y;
		var dist = Math.sqrt(dx * dx + dy * dy);
		if (dist > 0) {
			self.x += dx / dist * self.speed;
			self.y += dy / dist * self.speed;
		}
	};
	// Take damage method
	self.takeDamage = function (dmg) {
		self.health -= dmg;
		if (self.health <= 0) {
			self.destroy();
			return true; // killed
		}
		// Flash on hit
		LK.effects.flashObject(self, 0xffffff, 120);
		return false; // not dead
	};
	return self;
});

/**** 
* Initialize Game
****/ 
var game = new LK.Game({
	backgroundColor: 0x222244 // Changed to a visible dark blue for better contrast
});

/**** 
* Game Code
****/ 
// Aiming line: thin yellow box (will be scaled)
// Zombie asset: greenish box
// Bullet asset: small ellipse
// Gun (player) asset: a box, centered
// Game constants
// Bullet class
var bulletColors = [0xffe066,
// yellow
0x2196f3,
// blue
0xff9800,
// orange
0xe91e63,
// pink
0x9c27b0,
// purple
0xffeb3b,
// yellow2
0x795548,
// brown
0x607d8b,
// gray-blue
0xf44336,
// red
0x00bcd4 // cyan
];
// Zombie class
var zombieColors = [0x4caf50,
// green
0x2196f3,
// blue
0xff9800,
// orange
0xe91e63,
// pink
0x9c27b0,
// purple
0xffeb3b,
// yellow
0x795548,
// brown
0x607d8b,
// gray-blue
0xf44336,
// red
0x00bcd4 // cyan
];
var GAME_W = 2048;
var GAME_H = 2732;
var PLAYER_X = GAME_W / 2;
var PLAYER_Y = GAME_H / 2; // Center of the screen
// Game state
var bullets = [];
var zombies = [];
var score = 0;
var isGameOver = false;
// Gun upgrade state
var gunLevel = 1;
var lastUpgradeScore = 0;
var bulletBaseSpeed = 40;
var aimLineBaseLen = 700;
// Create gun/player
var gun = new Gun();
gun.x = PLAYER_X;
gun.y = PLAYER_Y;
game.addChild(gun);
// Create aiming line
var aimLine = new AimLine();
aimLine.x = gun.x;
aimLine.y = gun.y;
game.addChild(aimLine);
// Score text
var scoreTxt = new Text2('0', {
	size: 120,
	fill: "#fff"
});
scoreTxt.anchor.set(0.5, 0);
LK.gui.top.addChild(scoreTxt);
// Helper: clamp
function clamp(val, min, max) {
	return Math.max(min, Math.min(max, val));
}
// Helper: spawn zombie at random edge, aiming at player
function spawnZombie() {
	// Determine zombie tier based on score at spawn
	var tier = Math.floor(score / 100);
	// Deterministic edge: cycle through edges in order (top, bottom, left, right)
	if (typeof spawnZombie.edgeIndex === "undefined") spawnZombie.edgeIndex = 0;
	var edge = spawnZombie.edgeIndex % 4;
	spawnZombie.edgeIndex++;
	var x, y;
	if (edge === 0) {
		// top
		x = 200;
		y = -80;
	} else if (edge === 1) {
		// bottom
		x = 200;
		y = GAME_H + 80;
	} else if (edge === 2) {
		// left
		x = -80;
		y = 300;
	} else {
		// right
		x = GAME_W + 80;
		y = 300;
	}
	var z = new Zombie();
	z.x = x;
	z.y = y;
	z.targetX = gun.x;
	z.targetY = gun.y;
	zombies.push(z);
	game.addChild(z);
}
// Helper: fire bullet toward (tx,ty)
function fireBullet(tx, ty) {
	// If score >= 20 and there are zombies, auto-aim at closest zombie
	var autoAim = score >= 20 && zombies.length > 0;
	var dx, dy, dist;
	if (autoAim) {
		// Find closest zombie to gun
		var minDist = Infinity;
		var closest = null;
		for (var i = 0; i < zombies.length; i++) {
			var z = zombies[i];
			var zx = z.x - gun.x;
			var zy = z.y - gun.y;
			var d = Math.sqrt(zx * zx + zy * zy);
			if (d < minDist) {
				minDist = d;
				closest = z;
			}
		}
		if (closest) {
			dx = closest.x - gun.x;
			dy = closest.y - gun.y;
			dist = Math.sqrt(dx * dx + dy * dy);
			// If zombie is on top of gun, fallback to normal aim
			if (dist < 10) {
				dx = tx - gun.x;
				dy = ty - gun.y;
				dist = Math.sqrt(dx * dx + dy * dy);
			}
		} else {
			dx = tx - gun.x;
			dy = ty - gun.y;
			dist = Math.sqrt(dx * dx + dy * dy);
		}
	} else {
		dx = tx - gun.x;
		dy = ty - gun.y;
		dist = Math.sqrt(dx * dx + dy * dy);
	}
	if (dist < 10) return; // Don't fire if too close
	dx /= dist;
	dy /= dist;
	// Only fire a single bullet, but set its bounces based on score
	// Bullet cap: max 100 bullets at once
	if (bullets.length >= 100) {
		return;
	}
	var angle = Math.atan2(dy, dx);
	var b = new Bullet();
	b.x = gun.x + Math.cos(angle) * 80; // Start a bit ahead of gun
	b.y = gun.y + Math.sin(angle) * 80;
	b.dx = Math.cos(angle);
	b.dy = Math.sin(angle);
	// Upgrade bullet speed, slow down at score >= 210
	if (score >= 210) {
		b.speed = 18 + (gunLevel - 1) * 2;
	} else {
		b.speed = bulletBaseSpeed + (gunLevel - 1) * 10;
	}
	// Track lastX and lastY for despawn logic
	b.lastX = b.x;
	b.lastY = b.y;
	bullets.push(b);
	game.addChild(b);
}
// Update aiming line to point from gun to (aimX, aimY)
function updateAimLine(aimX, aimY) {
	var dx = aimX - gun.x;
	var dy = aimY - gun.y;
	var dist = Math.sqrt(dx * dx + dy * dy);
	// Clamp min/max length
	var minLen = 120,
		maxLen = aimLineBaseLen + (gunLevel - 1) * 80;
	var len = clamp(dist, minLen, maxLen);
	// Set scaleX of line
	aimLine.scale.x = len / 20; // asset width is 20
	// Set rotation
	aimLine.rotation = Math.atan2(dy, dx);
}
// Initial aim position: straight up
var aimX = gun.x;
var aimY = gun.y - 400;
updateAimLine(aimX, aimY);
// Touch/mouse move: update aim
game.move = function (x, y, obj) {
	// Clamp aim point to inside game area
	aimX = clamp(x, 100, GAME_W - 100);
	aimY = clamp(y, 100, GAME_H - 100);
	updateAimLine(aimX, aimY);
};
// Touch/mouse down: fire bullet
game.down = function (x, y, obj) {
	if (isGameOver) return;
	// Only fire on left click/tap (event.button==0 or undefined for touch)
	if (!obj || !obj.event || obj.event.button === undefined || obj.event.button === 0) {
		fireBullet(x, y);
	}
};
// Right click: spin gun and toggle spin state
game.rightClickSpinState = false;
game.rightClickSpinTween = null;
game.rightClick = function (x, y, obj) {
	if (isGameOver) return;
	// Toggle spin state
	game.rightClickSpinState = !game.rightClickSpinState;
	// If already spinning, stop previous tween
	if (game.rightClickSpinTween) {
		tween.kill(game.rightClickSpinTween);
		game.rightClickSpinTween = null;
	}
	if (game.rightClickSpinState) {
		// Spin gun 2 full turns (4*PI) over 0.7s
		var startRot = gun.rotation;
		var endRot = startRot + Math.PI * 4;
		game.rightClickSpinTween = tween.to(gun, {
			rotation: endRot
		}, 700, {
			easing: "easeInOutCubic"
		});
	} else {
		// Spin back to original (0) over 0.7s
		var curRot = gun.rotation;
		// Normalize to [-PI, PI] for shortest path
		var normRot = (curRot % (Math.PI * 2) + Math.PI * 2) % (Math.PI * 2);
		if (normRot > Math.PI) normRot -= Math.PI * 2;
		game.rightClickSpinTween = tween.to(gun, {
			rotation: 0
		}, 700, {
			easing: "easeInOutCubic"
		});
	}
};
// Listen for right click (button==2)
game.on('down', function (x, y, obj) {
	if (isGameOver) return;
	if (obj && obj.event && obj.event.button === 2) {
		game.rightClick(x, y, obj);
	}
});
// Prevent context menu on right click
if (typeof window !== "undefined" && window.addEventListener) {
	window.addEventListener("contextmenu", function (e) {
		e.preventDefault();
	});
}
// No drag, so up is not needed
// Game update loop
game.update = function () {
	if (isGameOver) return;
	// Update all bullets (no artificial cap that breaks at high scores)
	for (var i = bullets.length - 1; i >= 0; i--) {
		var b = bullets[i];
		// Track previous position for despawn logic
		if (typeof b.lastX === "undefined") b.lastX = b.x;
		if (typeof b.lastY === "undefined") b.lastY = b.y;
		// Only update if bullet is on screen (with margin)
		if (b.x > -200 && b.x < GAME_W + 200 && b.y > -200 && b.y < GAME_H + 200) {
			b.update();
		}
		// Despawn bullet if it just left the screen bounds
		if (b.lastX >= -100 && b.x < -100 || b.lastX <= GAME_W + 100 && b.x > GAME_W + 100 || b.lastY >= -100 && b.y < -100 || b.lastY <= GAME_H + 100 && b.y > GAME_H + 100) {
			b.destroy();
			bullets.splice(i, 1);
			continue;
		}
		// Update lastX/lastY for next frame
		b.lastX = b.x;
		b.lastY = b.y;
		// Check collision with zombies, but limit checks per bullet for lag reduction
		var MAX_ZOMBIE_COLLISION_CHECKS = 40;
		var zombiesChecked = 0;
		for (var j = zombies.length - 1; j >= 0; j--) {
			if (zombiesChecked++ >= MAX_ZOMBIE_COLLISION_CHECKS) break;
			var z = zombies[j];
			if (b.intersects(z)) {
				// Hit!
				var killed = false;
				if (typeof z.takeDamage === "function") {
					killed = z.takeDamage(b.damage || 1);
				} else {
					// fallback for old zombies
					z.destroy();
					killed = true;
				}
				if (killed) {
					zombies.splice(j, 1);
					// Score up
					score += 1;
					scoreTxt.setText(score);
					// Gun upgrade every 5 kills
					if (score > 0 && score % 5 === 0 && score !== lastUpgradeScore) {
						gunLevel += 1;
						lastUpgradeScore = score;
						// Optionally flash gun blue to show upgrade
						LK.effects.flashObject(gun, 0x3399ff, 500);
					}
					// Flash gun green for kill
					LK.effects.flashObject(gun, 0x00ff00, 200);
				}
				// Bullet bounce logic: bounce to next zombie if bounces left, else destroy
				if (typeof b.bouncesLeft === "undefined") b.bouncesLeft = 1 + Math.floor(score / 10);
				if (typeof b.lastHitZombies === "undefined") b.lastHitZombies = [];
				b.lastHitZombies.push(z);
				// If bullet has bounces left, retarget to next zombie
				b.bouncesLeft--;
				if (b.bouncesLeft > 0 && zombies.length > 1) {
					// Find next closest zombie not already hit
					var minDist = Infinity;
					var nextTarget = null;
					for (var zz = 0; zz < zombies.length; zz++) {
						var z2 = zombies[zz];
						if (z2 === z) continue;
						if (b.lastHitZombies.indexOf(z2) !== -1) continue;
						var zx = z2.x - b.x;
						var zy = z2.y - b.y;
						var d = Math.sqrt(zx * zx + zy * zy);
						if (d < minDist) {
							minDist = d;
							nextTarget = z2;
						}
					}
					if (nextTarget) {
						// Set direction to next zombie
						var dx = nextTarget.x - b.x;
						var dy = nextTarget.y - b.y;
						var dist = Math.sqrt(dx * dx + dy * dy);
						if (dist > 0) {
							b.dx = dx / dist;
							b.dy = dy / dist;
							b.justBounced = true;
						}
						// Do not destroy bullet, let it continue
						break;
					}
				}
				// No bounces left or no valid target, destroy bullet
				b.destroy();
				bullets.splice(i, 1);
				break;
			}
		}
	}
	// Update all zombies (no artificial cap that breaks at high scores)
	for (var k = zombies.length - 1; k >= 0; k--) {
		var z = zombies[k];
		// Make it easier at score >= 200: reduce zombie speed
		if (score >= 200) {
			z.speed = Math.max(2, z.speed * 0.7);
		}
		// Only update if zombie is on screen (with margin)
		if (z.x > -200 && z.x < GAME_W + 200 && z.y > -200 && z.y < GAME_H + 200) {
			z.update();
		}
		// Check if zombie reached player (gun)
		if (z.intersects(gun)) {
			// Game over
			isGameOver = true;
			LK.effects.flashScreen(0xff0000, 1000);
			// Show game over and then leaderboard
			LK.showGameOver(function () {
				LK.showLeaderboard({
					score: score
				});
			});
			return;
		}
	}
	// Make it easier at score >= 200: increase bullet bounces
	if (score >= 200) {
		for (var i = 0; i < bullets.length; i++) {
			var b = bullets[i];
			if (typeof b.bouncesLeft !== "undefined") {
				// Give at least 2 extra bounces at 200+
				b.bouncesLeft = Math.max(b.bouncesLeft, 3 + Math.floor(score / 100));
			}
		}
	}
	// Spawn zombies at intervals, but reduce max zombies as score increases (never limit bullets)
	var baseMax = 120;
	var tier = Math.floor(score / 100);
	var MAX_ZOMBIES = baseMax - tier * 15;
	if (MAX_ZOMBIES < 10) MAX_ZOMBIES = 10;
	if (score >= 1200) MAX_ZOMBIES = 10;
	// Cap zombies to always be less than bullet cap (60 at score >= 209)
	if (score >= 209) {
		MAX_ZOMBIES = Math.min(MAX_ZOMBIES, 40);
	}
	if (LK.ticks % 60 === 0) {
		// Every 1s
		// Increase spawn rate as score increases
		var toSpawn = 1 + Math.floor(score / 10);
		for (var s = 0; s < toSpawn; s++) {
			if (zombies.length < MAX_ZOMBIES) {
				spawnZombie();
			}
		}
	}
	// No cap on number of bullets in play
};
// Reset state on game restart
game.on('reset', function () {
	// Remove all bullets/zombies
	for (var i = 0; i < bullets.length; i++) bullets[i].destroy();
	for (var j = 0; j < zombies.length; j++) zombies[j].destroy();
	bullets = [];
	zombies = [];
	score = 0;
	isGameOver = false;
	scoreTxt.setText(score);
	// Reset gun upgrades
	gunLevel = 1;
	lastUpgradeScore = 0;
	// Reset gun spin state
	game.rightClickSpinState = false;
	if (game.rightClickSpinTween) {
		tween.kill(game.rightClickSpinTween);
		game.rightClickSpinTween = null;
	}
	gun.rotation = 0;
	// Reset aim
	aimX = gun.x;
	aimY = gun.y - 400;
	updateAimLine(aimX, aimY);
	// Add leaderboard button to GUI (top right)
	if (!game.leaderboardBtn) {
		var leaderboardBtn = new Text2("🏆", {
			size: 100,
			fill: 0xFFE066
		});
		leaderboardBtn.anchor.set(1, 0);
		leaderboardBtn.interactive = true;
		leaderboardBtn.buttonMode = true;
		leaderboardBtn.x = -40;
		leaderboardBtn.y = 20;
		leaderboardBtn.down = function () {
			LK.showLeaderboard({
				score: score
			});
		};
		LK.gui.topRight.addChild(leaderboardBtn);
		game.leaderboardBtn = leaderboardBtn;
	}
});

===================================================================
--- original.js
+++ change.js
@@ -348,10 +348,10 @@
 	if (dist < 10) return; // Don't fire if too close
 	dx /= dist;
 	dy /= dist;
 	// Only fire a single bullet, but set its bounces based on score
-	// Bullet cap: at score >= 209, max 60 bullets at once
-	if (score >= 209 && bullets.length >= 60) {
+	// Bullet cap: max 100 bullets at once
+	if (bullets.length >= 100) {
 		return;
 	}
 	var angle = Math.atan2(dy, dx);
 	var b = new Bullet();