/**** 
* 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 () {
		// After 20 kills, home in on closest zombie
		if (score >= 20 && zombies && zombies.length > 0) {
			// Find closest zombie to bullet
			var minDist = Infinity;
			var closest = null;
			for (var i = 0; i < zombies.length; i++) {
				var z = zombies[i];
				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; // 0=none, 1=instant turn
					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;
					}
				}
			}
		}
		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 = 4 + Math.random() * 2 + tier * 0.5; // Slight speed and tier bonus
	// 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
****/ 
// Bullet class
// Game constants
// Gun (player) asset: a box, centered
// Bullet asset: small ellipse
// Zombie asset: greenish box
// Aiming line: thin yellow box (will be scaled)
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);
	// Pick random edge: 0=top, 1=bottom, 2=left, 3=right
	var edge = Math.floor(Math.random() * 4);
	var x, y;
	if (edge === 0) {
		// top
		x = 200 + Math.random() * (GAME_W - 400);
		y = -80;
	} else if (edge === 1) {
		// bottom
		x = 200 + Math.random() * (GAME_W - 400);
		y = GAME_H + 80;
	} else if (edge === 2) {
		// left
		x = -80;
		y = 300 + Math.random() * (GAME_H - 600);
	} else {
		// right
		x = GAME_W + 80;
		y = 300 + Math.random() * (GAME_H - 600);
	}
	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;
	// Calculate number of bullets to fire: 1 + 1 per 10 kills (score), no cap
	var extraBullets = Math.floor(score / 10);
	var numBullets = 1 + extraBullets;
	if (numBullets < 1) numBullets = 1;
	// Fire bullets in a spread (if more than 1)
	var spreadAngle = Math.PI / 12; // 15 degrees total spread for max bullets
	for (var n = 0; n < numBullets; n++) {
		var angle = Math.atan2(dy, dx);
		// Center bullet is straight, others are spread left/right
		var offset = 0;
		if (numBullets > 1) {
			offset = (n - (numBullets - 1) / 2) * (spreadAngle / Math.max(1, numBullets - 1));
		}
		var bulletAngle = angle + offset;
		var b = new Bullet();
		b.x = gun.x + Math.cos(bulletAngle) * 80; // Start a bit ahead of gun
		b.y = gun.y + Math.sin(bulletAngle) * 80;
		b.dx = Math.cos(bulletAngle);
		b.dy = Math.sin(bulletAngle);
		// Upgrade bullet speed, but cap at 120 kills
		var cappedScore = Math.min(score, 120);
		b.speed = bulletBaseSpeed + (gunLevel - 1) * 10;
		if (score > 120) {
			// After 120 kills, bullet speed does not increase further
			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);
				}
				// Destroy bullet on hit
				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];
		// 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;
		}
	}
	// Spawn zombies at intervals, but limit max zombies for lag reduction
	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;
	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
@@ -21,17 +21,24 @@
 });
 // Bullet class
 var Bullet = Container.expand(function () {
 	var self = Container.call(this);
-	// Attach bullet asset, center anchor
+	// 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
+		anchorY: 0.5,
+		color: bulletColors[tier]
 	});
 	// Direction vector (set on spawn)
 	self.dx = 0;
 	self.dy = 0;
-	self.speed = 40; // px per frame
+	self.speed = 40 + tier * 2; // px per frame, slight speed bonus per tier
+	// Damage increases with tier
+	self.damage = 1 + tier;
 	self.update = function () {
 		// After 20 kills, home in on closest zombie
 		if (score >= 20 && zombies && zombies.length > 0) {
 			// Find closest zombie to bullet
@@ -84,17 +91,25 @@
 });
 // Zombie class
 var Zombie = Container.expand(function () {
 	var self = Container.call(this);
-	// Attach zombie asset, center anchor
+	// 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
+		anchorY: 0.5,
+		color: zombieColors[tier]
 	});
 	// Target position (player center)
 	self.targetX = 0;
 	self.targetY = 0;
-	self.speed = 4 + Math.random() * 2; // Slight speed variation
+	self.speed = 4 + Math.random() * 2 + tier * 0.5; // Slight speed and tier bonus
+	// 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;
@@ -103,8 +118,19 @@
 			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;
 });
 
 /**** 
@@ -116,13 +142,55 @@
 
 /**** 
 * Game Code
 ****/ 
+// Bullet class
 // Game constants
 // Gun (player) asset: a box, centered
 // Bullet asset: small ellipse
 // Zombie asset: greenish box
 // Aiming line: thin yellow box (will be scaled)
+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
@@ -158,9 +226,10 @@
 	return Math.max(min, Math.min(max, val));
 }
 // Helper: spawn zombie at random edge, aiming at player
 function spawnZombie() {
-	var z = new Zombie();
+	// Determine zombie tier based on score at spawn
+	var tier = Math.floor(score / 100);
 	// Pick random edge: 0=top, 1=bottom, 2=left, 3=right
 	var edge = Math.floor(Math.random() * 4);
 	var x, y;
 	if (edge === 0) {
@@ -179,20 +248,13 @@
 		// right
 		x = GAME_W + 80;
 		y = 300 + Math.random() * (GAME_H - 600);
 	}
+	var z = new Zombie();
 	z.x = x;
 	z.y = y;
 	z.targetX = gun.x;
 	z.targetY = gun.y;
-	// Stop zombie speed increase at 120 kills
-	if (score > 120) {
-		z.speed = 4 + Math.random() * 2;
-	} else {
-		// Optionally, you could have a speed formula that increases up to 120 kills, but current code is fixed
-		// If you want to increase speed up to 120 kills, you could do:
-		// z.speed = (4 + Math.random() * 2) + (score / 120) * SPEED_INCREASE;
-	}
 	zombies.push(z);
 	game.addChild(z);
 }
 // Helper: fire bullet toward (tx,ty)
@@ -380,24 +442,34 @@
 			if (zombiesChecked++ >= MAX_ZOMBIE_COLLISION_CHECKS) break;
 			var z = zombies[j];
 			if (b.intersects(z)) {
 				// Hit!
-				z.destroy();
-				zombies.splice(j, 1);
+				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);
+				}
+				// Destroy bullet on hit
 				b.destroy();
 				bullets.splice(i, 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 zombie green
-				LK.effects.flashObject(gun, 0x00ff00, 200);
 				break;
 			}
 		}
 	}
@@ -422,10 +494,13 @@
 			return;
 		}
 	}
 	// Spawn zombies at intervals, but limit max zombies for lag reduction
-	var MAX_ZOMBIES = Math.min(120, 1 + Math.floor(score / 10) * 10); // Cap at 120 at 120 kills
-	if (score >= 1200) MAX_ZOMBIES = 120;
+	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;
 	if (LK.ticks % 60 === 0) {
 		// Every 1s
 		// Increase spawn rate as score increases
 		var toSpawn = 1 + Math.floor(score / 10);