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

/**** 
* Classes
****/ 
var Bullet = Container.expand(function () {
	var self = Container.call(this);
	var bulletGraphics = self.attachAsset('bullet', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.velocityX = 0;
	self.velocityY = 0;
	self.damage = 100;
	self.speed = 10;
	self.isInstantKill = false;
	self.update = function () {
		// Move bullet with constant velocity
		self.x += self.velocityX;
		self.y += self.velocityY;
		// If player has pistol weapon, make bullets behave like punches at range boundary
		if (player && player.hasWeapon && player.weaponType === 'pistol') {
			// Calculate distance from player center
			var dx = self.x - player.x;
			var dy = self.y - player.y;
			var distanceFromPlayer = Math.sqrt(dx * dx + dy * dy);
			// Check if bullet is at range circle boundary (considering 1.25x scale)
			var effectiveRange = player.range * 1.25; // Range circle is 25% bigger with pistol
			if (distanceFromPlayer >= effectiveRange) {
				// Slow down bullet velocities when hitting red area boundary
				self.velocityX *= 0.5;
				self.velocityY *= 0.5;
				// Return bullet to player
				self.velocityX = (player.x - self.x) * 0.15;
				self.velocityY = (player.y - self.y) * 0.15;
				// Check if bullet has returned to player
				if (distanceFromPlayer >= effectiveRange && Math.sqrt((player.x - self.x) * (player.x - self.x) + (player.y - self.y) * (player.y - self.y)) < 50) {
					// Add bullet back to inventory
					if (bulletCount < maxBullets) {
						bulletCount++;
					}
					// Remove from bullets array and destroy
					var index = bullets.indexOf(self);
					if (index !== -1) {
						bullets.splice(index, 1);
					}
					self.destroy();
				}
			}
		}
		// Remove if off screen
		if (self.x < -50 || self.x > 2098 || self.y < -50 || self.y > 2782) {
			var index = bullets.indexOf(self);
			if (index !== -1) {
				bullets.splice(index, 1);
			}
			self.destroy();
		}
	};
	return self;
});
var Coin = Container.expand(function () {
	var self = Container.call(this);
	var coinGraphics = self.attachAsset('coin', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.value = 10;
	self.lastPlayerDistance = Infinity;
	// Start small and grow when spawned
	self.scaleX = 0.1;
	self.scaleY = 0.1;
	tween(self, {
		scaleX: 1.75,
		scaleY: 1.75
	}, {
		duration: 800,
		easing: tween.bounceOut
	});
	self.update = function () {
		var dx = player.x - self.x;
		var dy = player.y - self.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		// Collect coin if player is close
		if (self.lastPlayerDistance > 40 && distance <= 40) {
			player.coins += self.value;
			// Save coins to storage
			storage.coins = player.coins;
			LK.getSound('coin').play();
			// Animate coin growing before collection
			tween(self, {
				scaleX: 2.8,
				scaleY: 2.8,
				alpha: 0
			}, {
				duration: 300,
				easing: tween.easeOut,
				onFinish: function onFinish() {
					var index = coins.indexOf(self);
					if (index !== -1) {
						coins.splice(index, 1);
					}
					self.destroy();
				}
			});
		}
		self.lastPlayerDistance = distance;
	};
	return self;
});
var HealthDrop = Container.expand(function () {
	var self = Container.call(this);
	var healthDropGraphics = self.attachAsset('healthDrop', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Tint the health drop red to look like a heart
	healthDropGraphics.tint = 0xFF0000;
	self.healAmount = 10; // 10% heal
	self.lastPlayerDistance = Infinity;
	// Start small and grow when spawned
	self.scaleX = 0.1;
	self.scaleY = 0.1;
	tween(self, {
		scaleX: 1.75,
		scaleY: 1.75
	}, {
		duration: 800,
		easing: tween.bounceOut
	});
	self.update = function () {
		var dx = player.x - self.x;
		var dy = player.y - self.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		// Collect health drop if player is close
		if (self.lastPlayerDistance > 40 && distance <= 40) {
			// Heal player by 5 health points - allow going over max health
			var healAmount = 5;
			player.health += healAmount;
			// Update max health if current health exceeds it
			if (player.health > player.maxHealth) {
				player.maxHealth = player.health;
			}
			if (player.healthText) {
				player.healthText.setText(player.health.toString());
			}
			LK.getSound('coin').play();
			// Animate health drop growing before collection
			tween(self, {
				scaleX: 2.8,
				scaleY: 2.8,
				alpha: 0
			}, {
				duration: 300,
				easing: tween.easeOut,
				onFinish: function onFinish() {
					var index = healthDrops.indexOf(self);
					if (index !== -1) {
						healthDrops.splice(index, 1);
					}
					self.destroy();
				}
			});
		}
		self.lastPlayerDistance = distance;
	};
	return self;
});
var LeftPunch = Container.expand(function () {
	var self = Container.call(this);
	// Create left punch
	var punchGraphics = self.attachAsset('leftPunch', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.velocityX = 0;
	self.velocityY = 0;
	self.damage = 25;
	self.isInstantKill = false;
	self.target = null; // Target zombie in red area
	self.isRotating = false; // Track if punch is rotating around circle
	self.rotationAngle = 0; // Current rotation angle
	self.rotationSpeed = 0; // Speed of rotation
	self.rotationCount = 0; // Count completed rotations
	self.maxRotations = 3; // Maximum rotations before destruction
	self.update = function () {
		// Find nearest zombie in red area if we don't have a target
		if (!self.target) {
			var nearestZombie = null;
			var minDistance = Infinity;
			for (var i = 0; i < zombies.length; i++) {
				var zombie = zombies[i];
				var dx = zombie.x - player.x;
				var dy = zombie.y - player.y;
				var distanceFromPlayer = Math.sqrt(dx * dx + dy * dy);
				if (distanceFromPlayer <= player.range && distanceFromPlayer < minDistance) {
					minDistance = distanceFromPlayer;
					nearestZombie = zombie;
				}
			}
			self.target = nearestZombie;
		}
		// Apply gravity to create parabolic arc
		self.velocityY += 0.3; // Gravity effect
		// If we have a target zombie, adjust trajectory towards it
		if (self.target && zombies.indexOf(self.target) !== -1) {
			var targetDx = self.target.x - self.x;
			var targetDy = self.target.y - self.y;
			var targetDistance = Math.sqrt(targetDx * targetDx + targetDy * targetDy);
			// Add slight homing effect (adjust velocity slightly towards target)
			if (targetDistance > 20) {
				var homingStrength = 0.1;
				self.velocityX += targetDx / targetDistance * homingStrength;
				self.velocityY += targetDy / targetDistance * homingStrength;
			}
		} else {
			// Clear target if zombie no longer exists
			self.target = null;
		}
		// Move punch with parabolic trajectory
		self.x += self.velocityX;
		self.y += self.velocityY;
		// Calculate distance from player center
		var dx = self.x - player.x;
		var dy = self.y - player.y;
		var distanceFromPlayer = Math.sqrt(dx * dx + dy * dy);
		// Check if punch is at range circle boundary
		if (distanceFromPlayer >= player.range) {
			// Slow down punch velocities when hitting red area boundary
			self.velocityX *= 0.5;
			self.velocityY *= 0.5;
			// Return punch to player as a bullet
			self.velocityX = (player.x - self.x) * 0.15;
			self.velocityY = (player.y - self.y) * 0.15;
			// Check if punch has returned to player
			if (distanceFromPlayer >= player.range && Math.sqrt((player.x - self.x) * (player.x - self.x) + (player.y - self.y) * (player.y - self.y)) < 50) {
				// Add bullet back to inventory
				if (bulletCount < maxBullets) {
					bulletCount++;
				}
				// Remove from bullets array and destroy
				var index = bullets.indexOf(self);
				if (index !== -1) {
					bullets.splice(index, 1);
				}
				self.destroy();
			}
		}
		// Remove if off screen
		if (self.x < -50 || self.x > 2098 || self.y < -50 || self.y > 2782) {
			var index = bullets.indexOf(self);
			if (index !== -1) {
				bullets.splice(index, 1);
			}
			self.destroy();
		}
	};
	return self;
});
// Game arrays
var Player = Container.expand(function () {
	var self = Container.call(this);
	var playerGraphics = self.attachAsset('player', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.health = 100;
	self.maxHealth = 100;
	self.speed = 5;
	self.damage = 25;
	self.armor = 0;
	self.coins = 0;
	self.shootCooldown = 0;
	self.range = 375;
	self.hasWeapon = false;
	self.weaponType = null;
	self.weaponDamage = 0;
	// Create range circle
	var rangeCircle = self.attachAsset('rangeCircle', {
		anchorX: 0.5,
		anchorY: 0.5,
		alpha: 0.2
	});
	rangeCircle.width = self.range * 2;
	rangeCircle.height = self.range * 2;
	// Create health text above player
	var healthText = new Text2(self.health.toString(), {
		size: 60,
		fill: 0x00FF00
	});
	healthText.anchor.set(0.5, 1);
	healthText.x = 0;
	healthText.y = -100;
	self.addChild(healthText);
	self.healthText = healthText;
	self.update = function () {
		if (self.shootCooldown > 0) {
			self.shootCooldown--;
		}
	};
	self.takeDamage = function (damage) {
		var actualDamage = Math.max(1, damage - self.armor);
		self.health -= actualDamage;
		if (self.healthText) {
			self.healthText.setText(Math.max(0, self.health).toString());
		}
		if (self.health <= 0) {
			self.health = 0;
			// Stop time tracking by setting gameStarted to false
			gameStarted = false;
			// Show death statistics before game over
			showDeathStats();
		}
	};
	self.updatePlayerGraphics = function () {
		// Remove current player graphics
		if (playerGraphics.parent) {
			playerGraphics.parent.removeChild(playerGraphics);
		}
		// Add new graphics based on weapon status
		if (self.hasWeapon && self.weaponType === 'pistol') {
			playerGraphics = self.attachAsset('playerPistol', {
				anchorX: 0.5,
				anchorY: 0.5
			});
			// Make range circle 25% bigger when player has pistol
			tween(rangeCircle, {
				scaleX: 1.25,
				scaleY: 1.25
			}, {
				duration: 500,
				easing: tween.easeOut
			});
		} else {
			playerGraphics = self.attachAsset('player', {
				anchorX: 0.5,
				anchorY: 0.5
			});
			// Reset range circle to normal size when no pistol
			tween(rangeCircle, {
				scaleX: 1,
				scaleY: 1
			}, {
				duration: 500,
				easing: tween.easeOut
			});
		}
	};
	self.shoot = function (targetX, targetY) {
		if (self.shootCooldown > 0 || bulletCount <= 0 || isReloading) return;
		var dx = targetX - self.x;
		var dy = targetY - self.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		// Check if target is within range
		if (distance > self.range) return;
		var bullet;
		// Use pistol bullets when weapon is equipped, otherwise use punches
		if (self.hasWeapon && self.weaponType === 'pistol') {
			bullet = new Bullet();
			bullet.x = self.x;
			bullet.y = self.y;
			bullet.velocityX = dx / distance * bullet.speed;
			bullet.velocityY = dy / distance * bullet.speed;
			bullet.damage = 100; // Ensure pistol bullets always deal 100 damage
			// Count pistol bullets and reset to normal player after 10
			pistolBulletsFired++;
			if (pistolBulletsFired >= 10) {
				self.hasWeapon = false;
				self.weaponType = null;
				self.weaponDamage = 0;
				pistolBulletsFired = 0;
				self.updatePlayerGraphics();
			}
		} else {
			// Alternate between left and right punches
			if (bulletsFired % 2 === 0) {
				bullet = new LeftPunch();
			} else {
				bullet = new RightPunch();
			}
			bullet.x = self.x;
			bullet.y = self.y;
			bullet.velocityX = dx / distance * 7.5;
			bullet.velocityY = dy / distance * 7.5 - 2; // Subtract initial upward velocity for arc
			bullet.damage = self.damage;
		}
		// Track bullets fired and assign instant kill property
		bulletsFired++;
		if (bulletsFired % 10 === 1) {
			// Every 10 bullets, randomly select 3 positions for instant kills
			instantKillBullets = [];
			var positions = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
			for (var k = 0; k < 3; k++) {
				var randomIndex = Math.floor(Math.random() * positions.length);
				instantKillBullets.push(positions[randomIndex]);
				positions.splice(randomIndex, 1);
			}
		}
		// Check if this bullet should be instant kill (only for punches, not pistol bullets)
		if (!self.hasWeapon || self.weaponType !== 'pistol') {
			var currentBulletPosition = (bulletsFired - 1) % 10 + 1;
			bullet.isInstantKill = instantKillBullets.indexOf(currentBulletPosition) !== -1;
		}
		bullets.push(bullet);
		game.addChild(bullet);
		LK.getSound('shoot').play();
		self.shootCooldown = 10;
		bulletCount--;
		// Start reloading if out of bullets
		if (bulletCount <= 0) {
			isReloading = true;
			reloadTimer = 180; // 3 seconds at 60fps
		}
	};
	return self;
});
var RightPunch = Container.expand(function () {
	var self = Container.call(this);
	// Create right punch
	var punchGraphics = self.attachAsset('rightPunch', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.velocityX = 0;
	self.velocityY = 0;
	self.damage = 25;
	self.isInstantKill = false;
	self.target = null; // Target zombie in red area
	self.isRotating = false; // Track if punch is rotating around circle
	self.rotationAngle = 0; // Current rotation angle
	self.rotationSpeed = 0; // Speed of rotation
	self.rotationCount = 0; // Count completed rotations
	self.maxRotations = 3; // Maximum rotations before destruction
	self.update = function () {
		// Find nearest zombie in red area if we don't have a target
		if (!self.target) {
			var nearestZombie = null;
			var minDistance = Infinity;
			for (var i = 0; i < zombies.length; i++) {
				var zombie = zombies[i];
				var dx = zombie.x - player.x;
				var dy = zombie.y - player.y;
				var distanceFromPlayer = Math.sqrt(dx * dx + dy * dy);
				if (distanceFromPlayer <= player.range && distanceFromPlayer < minDistance) {
					minDistance = distanceFromPlayer;
					nearestZombie = zombie;
				}
			}
			self.target = nearestZombie;
		}
		// Apply gravity to create parabolic arc
		self.velocityY += 0.3; // Gravity effect
		// If we have a target zombie, adjust trajectory towards it
		if (self.target && zombies.indexOf(self.target) !== -1) {
			var targetDx = self.target.x - self.x;
			var targetDy = self.target.y - self.y;
			var targetDistance = Math.sqrt(targetDx * targetDx + targetDy * targetDy);
			// Add slight homing effect (adjust velocity slightly towards target)
			if (targetDistance > 20) {
				var homingStrength = 0.1;
				self.velocityX += targetDx / targetDistance * homingStrength;
				self.velocityY += targetDy / targetDistance * homingStrength;
			}
		} else {
			// Clear target if zombie no longer exists
			self.target = null;
		}
		// Move punch with parabolic trajectory
		self.x += self.velocityX;
		self.y += self.velocityY;
		// Calculate distance from player center
		var dx = self.x - player.x;
		var dy = self.y - player.y;
		var distanceFromPlayer = Math.sqrt(dx * dx + dy * dy);
		// Check if punch is at range circle boundary
		if (distanceFromPlayer >= player.range) {
			// Slow down punch velocities when hitting red area boundary
			self.velocityX *= 0.5;
			self.velocityY *= 0.5;
			// Return punch to player as a bullet
			self.velocityX = (player.x - self.x) * 0.15;
			self.velocityY = (player.y - self.y) * 0.15;
			// Check if punch has returned to player
			if (distanceFromPlayer >= player.range && Math.sqrt((player.x - self.x) * (player.x - self.x) + (player.y - self.y) * (player.y - self.y)) < 50) {
				// Add bullet back to inventory
				if (bulletCount < maxBullets) {
					bulletCount++;
				}
				// Remove from bullets array and destroy
				var index = bullets.indexOf(self);
				if (index !== -1) {
					bullets.splice(index, 1);
				}
				self.destroy();
			}
		}
		// Remove if off screen
		if (self.x < -50 || self.x > 2098 || self.y < -50 || self.y > 2782) {
			var index = bullets.indexOf(self);
			if (index !== -1) {
				bullets.splice(index, 1);
			}
			self.destroy();
		}
	};
	return self;
});
var Weapon = Container.expand(function () {
	var self = Container.call(this);
	var weaponGraphics = self.attachAsset('pistol', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.weaponType = 'pistol';
	self.damage = 100; // Pistol damage set to 100
	self.cost = 500; // Cost to purchase pistol
	self.lastPlayerDistance = Infinity;
	// Create cost text above weapon
	var costText = new Text2('500 coins', {
		size: 35,
		fill: 0xFFD700
	});
	costText.anchor.set(0.5, 1);
	costText.x = 0;
	costText.y = -60;
	self.addChild(costText);
	self.costText = costText;
	// Start small and grow when spawned
	self.scaleX = 0.1;
	self.scaleY = 0.1;
	tween(self, {
		scaleX: 1.5,
		scaleY: 1.5
	}, {
		duration: 800,
		easing: tween.bounceOut
	});
	self.update = function () {
		var dx = player.x - self.x;
		var dy = player.y - self.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		// Collect weapon if player is close and has enough coins
		if (self.lastPlayerDistance > 40 && distance <= 40) {
			if (player.coins >= self.cost) {
				// Deduct coins
				player.coins -= self.cost;
				// Save coins to storage
				storage.coins = player.coins;
				// Give player the weapon
				player.hasWeapon = true;
				player.weaponType = self.weaponType;
				player.weaponDamage = self.damage;
				// Reset pistol bullet counter to start from 1
				pistolBulletsFired = 0;
				// Fill bullets to maximum when picking up pistol
				bulletCount = maxBullets;
				isReloading = false;
				// Update player graphics to show pistol
				player.updatePlayerGraphics();
				LK.getSound('coin').play();
				// Animate weapon growing before collection
				tween(self, {
					scaleX: 2.5,
					scaleY: 2.5,
					alpha: 0
				}, {
					duration: 300,
					easing: tween.easeOut,
					onFinish: function onFinish() {
						var index = weapons.indexOf(self);
						if (index !== -1) {
							weapons.splice(index, 1);
						}
						self.destroy();
					}
				});
			}
		}
		self.lastPlayerDistance = distance;
	};
	return self;
});
var Zombie = Container.expand(function () {
	var self = Container.call(this);
	var zombieGraphics = self.attachAsset('zombie', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.health = 100;
	self.maxHealth = 100;
	self.speed = 2;
	self.damage = 20;
	self.coinValue = 10;
	self.lastPlayerDistance = Infinity;
	self.isPatrolling = false;
	self.patrolTimer = 0;
	self.patrolDuration = 0;
	self.targetX = 0;
	self.targetY = 0;
	self.waypoints = [];
	self.currentWaypointIndex = 0;
	self.pathUpdateTimer = 0;
	self.lastPlayerX = 0;
	self.lastPlayerY = 0;
	// Create health text above zombie
	var healthText = new Text2(self.health.toString(), {
		size: 40,
		fill: 0xFF0000
	});
	healthText.anchor.set(0.5, 1);
	healthText.x = 0;
	healthText.y = -80;
	self.addChild(healthText);
	self.healthText = healthText;
	self.update = function () {
		var dx = player.x - self.x;
		var dy = player.y - self.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		// Check if zombie is inside red area (player range)
		var insideRedArea = distance <= player.range;
		// If zombie enters red area while patrolling, stop patrolling and attack
		if (self.isPatrolling && insideRedArea) {
			self.isPatrolling = false;
		}
		if (insideRedArea) {
			// Inside red area - use AI pathfinding behavior
			self.pathUpdateTimer++;
			// Update path every 30 frames (0.5 seconds) or if player moved significantly
			var playerMoved = Math.abs(player.x - self.lastPlayerX) > 50 || Math.abs(player.y - self.lastPlayerY) > 50;
			if (self.pathUpdateTimer >= 30 || playerMoved || self.waypoints.length === 0) {
				self.pathUpdateTimer = 0;
				self.lastPlayerX = player.x;
				self.lastPlayerY = player.y;
				// Generate waypoints for AI movement
				self.waypoints = [];
				self.currentWaypointIndex = 0;
				// Create 2-4 waypoints between zombie and player
				var waypointCount = Math.floor(Math.random() * 3) + 2; // 2-4 waypoints
				var stepX = (player.x - self.x) / (waypointCount + 1);
				var stepY = (player.y - self.y) / (waypointCount + 1);
				for (var w = 1; w <= waypointCount; w++) {
					var baseX = self.x + stepX * w;
					var baseY = self.y + stepY * w;
					// Add random offset to create non-linear path
					var offsetRange = 150;
					var offsetX = (Math.random() - 0.5) * offsetRange;
					var offsetY = (Math.random() - 0.5) * offsetRange;
					var waypointX = Math.max(50, Math.min(1998, baseX + offsetX));
					var waypointY = Math.max(50, Math.min(2682, baseY + offsetY));
					self.waypoints.push({
						x: waypointX,
						y: waypointY
					});
				}
				// Add final waypoint near player
				self.waypoints.push({
					x: player.x,
					y: player.y
				});
			}
			// Move towards current waypoint
			if (self.waypoints.length > 0 && self.currentWaypointIndex < self.waypoints.length) {
				var currentWaypoint = self.waypoints[self.currentWaypointIndex];
				var waypointDx = currentWaypoint.x - self.x;
				var waypointDy = currentWaypoint.y - self.y;
				var waypointDistance = Math.sqrt(waypointDx * waypointDx + waypointDy * waypointDy);
				if (waypointDistance > 20) {
					// Move towards waypoint with slight speed variation for more natural movement
					var speedVariation = 0.8 + Math.random() * 0.4; // 0.8 to 1.2 speed multiplier
					self.x += waypointDx / waypointDistance * self.speed * speedVariation;
					self.y += waypointDy / waypointDistance * self.speed * speedVariation;
				} else {
					// Reached waypoint, move to next one
					self.currentWaypointIndex++;
				}
			} else {
				// Fallback to direct movement if no waypoints
				if (distance > 5) {
					self.x += dx / distance * self.speed;
					self.y += dy / distance * self.speed;
				}
			}
		} else if (self.isPatrolling) {
			// Outside red area - use patrol behavior
			// Move towards target patrol position
			var targetDx = self.targetX - self.x;
			var targetDy = self.targetY - self.y;
			var targetDistance = Math.sqrt(targetDx * targetDx + targetDy * targetDy);
			if (targetDistance > 5) {
				self.x += targetDx / targetDistance * self.speed;
				self.y += targetDy / targetDistance * self.speed;
			}
			// Update patrol duration
			self.patrolDuration--;
			if (self.patrolDuration <= 0) {
				self.isPatrolling = false;
			} else {
				// Update patrol timer for position changes
				self.patrolTimer--;
				if (self.patrolTimer <= 0) {
					// Choose new patrol position around red area border
					var angle = Math.random() * Math.PI * 2;
					var radius = player.range + 20; // Just outside red area
					self.targetX = player.x + Math.cos(angle) * radius;
					self.targetY = player.y + Math.sin(angle) * radius;
					// Keep patrol position within screen bounds
					self.targetX = Math.max(50, Math.min(1998, self.targetX));
					self.targetY = Math.max(50, Math.min(2682, self.targetY));
					// Set new patrol timer (1-5 seconds)
					self.patrolTimer = Math.floor(Math.random() * 240) + 60; // 60-300 frames (1-5 seconds)
				}
			}
		} else {
			// Outside red area and not patrolling - direct movement towards player
			if (distance > 5) {
				self.x += dx / distance * self.speed;
				self.y += dy / distance * self.speed;
			}
		}
		// Check collision with player
		if (self.lastPlayerDistance > 30 && distance <= 30 && !self.isPatrolling) {
			player.takeDamage(self.damage);
			LK.getSound('hit').play();
			// Add visual feedback with tween
			tween(self, {
				alpha: 0.5
			}, {
				duration: 200
			});
			tween(self, {
				alpha: 1
			}, {
				duration: 200,
				onFinish: function onFinish() {}
			});
			// Start patrolling after damaging player
			self.isPatrolling = true;
			self.patrolDuration = 180; // 3 seconds at 60 FPS
			var angle = Math.random() * Math.PI * 2;
			var radius = player.range + 20; // Just outside red area
			self.targetX = player.x + Math.cos(angle) * radius;
			self.targetY = player.y + Math.sin(angle) * radius;
			// Keep patrol position within screen bounds
			self.targetX = Math.max(50, Math.min(1998, self.targetX));
			self.targetY = Math.max(50, Math.min(2682, self.targetY));
			// Set patrol timer (1-5 seconds)
			self.patrolTimer = Math.floor(Math.random() * 240) + 60; // 60-300 frames (1-5 seconds)
		}
		self.lastPlayerDistance = distance;
	};
	self.takeDamage = function (damage) {
		self.health -= damage;
		if (self.healthText) {
			self.healthText.setText(Math.max(0, self.health).toString());
		}
		if (self.health <= 0) {
			self.die();
		}
	};
	self.die = function () {
		// Track total zombies killed
		totalZombiesKilled++;
		// Check if boss should spawn (every 30 kills)
		if (totalZombiesKilled - lastBossSpawn >= 30) {
			lastBossSpawn = totalZombiesKilled;
			// Spawn boss zombie5
			var boss = new Zombie5();
			var side = Math.floor(Math.random() * 4);
			switch (side) {
				case 0:
					// Top
					boss.x = Math.random() * 2048;
					boss.y = -50;
					break;
				case 1:
					// Right
					boss.x = 2098;
					boss.y = Math.random() * 2732;
					break;
				case 2:
					// Bottom
					boss.x = Math.random() * 2048;
					boss.y = 2782;
					break;
				case 3:
					// Left
					boss.x = -50;
					boss.y = Math.random() * 2732;
					break;
			}
			zombies.push(boss);
			game.addChild(boss);
		}
		// If player health is not 100, 100% chance to drop health, otherwise drop coin
		// If player health is 100, 6.75% chance to drop health, otherwise drop coin
		var healthDropChance = player.health < 100 ? 1.0 : 0.0675;
		if (Math.random() < healthDropChance) {
			var healthDrop = new HealthDrop();
			healthDrop.x = self.x;
			healthDrop.y = self.y;
			healthDrops.push(healthDrop);
			game.addChild(healthDrop);
		} else {
			var coin = new Coin();
			coin.x = self.x;
			coin.y = self.y;
			coin.value = self.coinValue;
			coins.push(coin);
			game.addChild(coin);
		}
		var index = zombies.indexOf(self);
		if (index !== -1) {
			zombies.splice(index, 1);
		}
		self.destroy();
	};
	return self;
});
var Zombie2 = Container.expand(function () {
	var self = Container.call(this);
	var zombieGraphics = self.attachAsset('zombie2', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.health = 150; // More health than regular zombie
	self.maxHealth = 150;
	self.speed = 3; // Faster than regular zombie
	self.damage = 30; // More damage than regular zombie
	self.coinValue = 15; // More coins when killed
	self.lastPlayerDistance = Infinity;
	self.isPatrolling = false;
	self.patrolTimer = 0;
	self.patrolDuration = 0;
	self.targetX = 0;
	self.targetY = 0;
	self.waypoints = [];
	self.currentWaypointIndex = 0;
	self.pathUpdateTimer = 0;
	self.lastPlayerX = 0;
	self.lastPlayerY = 0;
	// Create health text above zombie (orange to match stronger zombie)
	var healthText = new Text2(self.health.toString(), {
		size: 40,
		fill: 0xFF8800
	});
	healthText.anchor.set(0.5, 1);
	healthText.x = 0;
	healthText.y = -80;
	self.addChild(healthText);
	self.healthText = healthText;
	self.update = function () {
		var dx = player.x - self.x;
		var dy = player.y - self.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		// Check if zombie is inside red area (player range)
		var insideRedArea = distance <= player.range;
		// If zombie enters red area while patrolling, stop patrolling and attack
		if (self.isPatrolling && insideRedArea) {
			self.isPatrolling = false;
		}
		if (insideRedArea) {
			// Inside red area - use AI pathfinding behavior
			self.pathUpdateTimer++;
			// Update path every 30 frames (0.5 seconds) or if player moved significantly
			var playerMoved = Math.abs(player.x - self.lastPlayerX) > 50 || Math.abs(player.y - self.lastPlayerY) > 50;
			if (self.pathUpdateTimer >= 30 || playerMoved || self.waypoints.length === 0) {
				self.pathUpdateTimer = 0;
				self.lastPlayerX = player.x;
				self.lastPlayerY = player.y;
				// Generate waypoints for AI movement
				self.waypoints = [];
				self.currentWaypointIndex = 0;
				// Create 2-4 waypoints between zombie and player
				var waypointCount = Math.floor(Math.random() * 3) + 2; // 2-4 waypoints
				var stepX = (player.x - self.x) / (waypointCount + 1);
				var stepY = (player.y - self.y) / (waypointCount + 1);
				for (var w = 1; w <= waypointCount; w++) {
					var baseX = self.x + stepX * w;
					var baseY = self.y + stepY * w;
					// Add random offset to create non-linear path
					var offsetRange = 150;
					var offsetX = (Math.random() - 0.5) * offsetRange;
					var offsetY = (Math.random() - 0.5) * offsetRange;
					var waypointX = Math.max(50, Math.min(1998, baseX + offsetX));
					var waypointY = Math.max(50, Math.min(2682, baseY + offsetY));
					self.waypoints.push({
						x: waypointX,
						y: waypointY
					});
				}
				// Add final waypoint near player
				self.waypoints.push({
					x: player.x,
					y: player.y
				});
			}
			// Move towards current waypoint
			if (self.waypoints.length > 0 && self.currentWaypointIndex < self.waypoints.length) {
				var currentWaypoint = self.waypoints[self.currentWaypointIndex];
				var waypointDx = currentWaypoint.x - self.x;
				var waypointDy = currentWaypoint.y - self.y;
				var waypointDistance = Math.sqrt(waypointDx * waypointDx + waypointDy * waypointDy);
				if (waypointDistance > 20) {
					// Move towards waypoint with slight speed variation for more natural movement
					var speedVariation = 0.8 + Math.random() * 0.4; // 0.8 to 1.2 speed multiplier
					self.x += waypointDx / waypointDistance * self.speed * speedVariation;
					self.y += waypointDy / waypointDistance * self.speed * speedVariation;
				} else {
					// Reached waypoint, move to next one
					self.currentWaypointIndex++;
				}
			} else {
				// Fallback to direct movement if no waypoints
				if (distance > 5) {
					self.x += dx / distance * self.speed;
					self.y += dy / distance * self.speed;
				}
			}
		} else if (self.isPatrolling) {
			// Outside red area - use patrol behavior
			// Move towards target patrol position
			var targetDx = self.targetX - self.x;
			var targetDy = self.targetY - self.y;
			var targetDistance = Math.sqrt(targetDx * targetDx + targetDy * targetDy);
			if (targetDistance > 5) {
				self.x += targetDx / targetDistance * self.speed;
				self.y += targetDy / targetDistance * self.speed;
			}
			// Update patrol duration
			self.patrolDuration--;
			if (self.patrolDuration <= 0) {
				self.isPatrolling = false;
			} else {
				// Update patrol timer for position changes
				self.patrolTimer--;
				if (self.patrolTimer <= 0) {
					// Choose new patrol position around red area border
					var angle = Math.random() * Math.PI * 2;
					var radius = player.range + 20; // Just outside red area
					self.targetX = player.x + Math.cos(angle) * radius;
					self.targetY = player.y + Math.sin(angle) * radius;
					// Keep patrol position within screen bounds
					self.targetX = Math.max(50, Math.min(1998, self.targetX));
					self.targetY = Math.max(50, Math.min(2682, self.targetY));
					// Set new patrol timer (1-5 seconds)
					self.patrolTimer = Math.floor(Math.random() * 240) + 60; // 60-300 frames (1-5 seconds)
				}
			}
		} else {
			// Outside red area and not patrolling - direct movement towards player
			if (distance > 5) {
				self.x += dx / distance * self.speed;
				self.y += dy / distance * self.speed;
			}
		}
		// Check collision with player
		if (self.lastPlayerDistance > 30 && distance <= 30 && !self.isPatrolling) {
			player.takeDamage(self.damage);
			LK.getSound('hit').play();
			// Add visual feedback with tween
			tween(self, {
				alpha: 0.5
			}, {
				duration: 200
			});
			tween(self, {
				alpha: 1
			}, {
				duration: 200,
				onFinish: function onFinish() {}
			});
			// Start patrolling after damaging player
			self.isPatrolling = true;
			self.patrolDuration = 180; // 3 seconds at 60 FPS
			var angle = Math.random() * Math.PI * 2;
			var radius = player.range + 20; // Just outside red area
			self.targetX = player.x + Math.cos(angle) * radius;
			self.targetY = player.y + Math.sin(angle) * radius;
			// Keep patrol position within screen bounds
			self.targetX = Math.max(50, Math.min(1998, self.targetX));
			self.targetY = Math.max(50, Math.min(2682, self.targetY));
			// Set patrol timer (1-5 seconds)
			self.patrolTimer = Math.floor(Math.random() * 240) + 60; // 60-300 frames (1-5 seconds)
		}
		self.lastPlayerDistance = distance;
	};
	self.takeDamage = function (damage) {
		self.health -= damage;
		if (self.healthText) {
			self.healthText.setText(Math.max(0, self.health).toString());
		}
		if (self.health <= 0) {
			self.die();
		}
	};
	self.die = function () {
		// Track total zombies killed
		totalZombiesKilled++;
		// Check if boss should spawn (every 30 kills)
		if (totalZombiesKilled - lastBossSpawn >= 30) {
			lastBossSpawn = totalZombiesKilled;
			// Spawn boss zombie5
			var boss = new Zombie5();
			var side = Math.floor(Math.random() * 4);
			switch (side) {
				case 0:
					// Top
					boss.x = Math.random() * 2048;
					boss.y = -50;
					break;
				case 1:
					// Right
					boss.x = 2098;
					boss.y = Math.random() * 2732;
					break;
				case 2:
					// Bottom
					boss.x = Math.random() * 2048;
					boss.y = 2782;
					break;
				case 3:
					// Left
					boss.x = -50;
					boss.y = Math.random() * 2732;
					break;
			}
			zombies.push(boss);
			game.addChild(boss);
		}
		// If player health is not 100, 100% chance to drop health, otherwise drop coin
		// If player health is 100, 6.75% chance to drop health, otherwise drop coin
		var healthDropChance = player.health < 100 ? 1.0 : 0.0675;
		if (Math.random() < healthDropChance) {
			var healthDrop = new HealthDrop();
			healthDrop.x = self.x;
			healthDrop.y = self.y;
			healthDrops.push(healthDrop);
			game.addChild(healthDrop);
		} else {
			var coin = new Coin();
			coin.x = self.x;
			coin.y = self.y;
			coin.value = self.coinValue;
			coins.push(coin);
			game.addChild(coin);
		}
		var index = zombies.indexOf(self);
		if (index !== -1) {
			zombies.splice(index, 1);
		}
		self.destroy();
	};
	return self;
});
var Zombie3 = Container.expand(function () {
	var self = Container.call(this);
	var zombieGraphics = self.attachAsset('zombie3', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.health = 200; // Even more health than zombie2
	self.maxHealth = 200;
	self.speed = 4; // Fastest zombie
	self.damage = 40; // Highest damage
	self.coinValue = 25; // Most coins when killed
	self.lastPlayerDistance = Infinity;
	self.isPatrolling = false;
	self.patrolTimer = 0;
	self.patrolDuration = 0;
	self.targetX = 0;
	self.targetY = 0;
	self.waypoints = [];
	self.currentWaypointIndex = 0;
	self.pathUpdateTimer = 0;
	self.lastPlayerX = 0;
	self.lastPlayerY = 0;
	// Create health text above zombie (purple to match strongest zombie)
	var healthText = new Text2(self.health.toString(), {
		size: 40,
		fill: 0xFF00FF
	});
	healthText.anchor.set(0.5, 1);
	healthText.x = 0;
	healthText.y = -80;
	self.addChild(healthText);
	self.healthText = healthText;
	self.update = function () {
		var dx = player.x - self.x;
		var dy = player.y - self.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		// Check if zombie is inside red area (player range)
		var insideRedArea = distance <= player.range;
		// If zombie enters red area while patrolling, stop patrolling and attack
		if (self.isPatrolling && insideRedArea) {
			self.isPatrolling = false;
		}
		if (insideRedArea) {
			// Inside red area - use AI pathfinding behavior
			self.pathUpdateTimer++;
			// Update path every 30 frames (0.5 seconds) or if player moved significantly
			var playerMoved = Math.abs(player.x - self.lastPlayerX) > 50 || Math.abs(player.y - self.lastPlayerY) > 50;
			if (self.pathUpdateTimer >= 30 || playerMoved || self.waypoints.length === 0) {
				self.pathUpdateTimer = 0;
				self.lastPlayerX = player.x;
				self.lastPlayerY = player.y;
				// Generate waypoints for AI movement
				self.waypoints = [];
				self.currentWaypointIndex = 0;
				// Create 2-4 waypoints between zombie and player
				var waypointCount = Math.floor(Math.random() * 3) + 2; // 2-4 waypoints
				var stepX = (player.x - self.x) / (waypointCount + 1);
				var stepY = (player.y - self.y) / (waypointCount + 1);
				for (var w = 1; w <= waypointCount; w++) {
					var baseX = self.x + stepX * w;
					var baseY = self.y + stepY * w;
					// Add random offset to create non-linear path
					var offsetRange = 150;
					var offsetX = (Math.random() - 0.5) * offsetRange;
					var offsetY = (Math.random() - 0.5) * offsetRange;
					var waypointX = Math.max(50, Math.min(1998, baseX + offsetX));
					var waypointY = Math.max(50, Math.min(2682, baseY + offsetY));
					self.waypoints.push({
						x: waypointX,
						y: waypointY
					});
				}
				// Add final waypoint near player
				self.waypoints.push({
					x: player.x,
					y: player.y
				});
			}
			// Move towards current waypoint
			if (self.waypoints.length > 0 && self.currentWaypointIndex < self.waypoints.length) {
				var currentWaypoint = self.waypoints[self.currentWaypointIndex];
				var waypointDx = currentWaypoint.x - self.x;
				var waypointDy = currentWaypoint.y - self.y;
				var waypointDistance = Math.sqrt(waypointDx * waypointDx + waypointDy * waypointDy);
				if (waypointDistance > 20) {
					// Move towards waypoint with slight speed variation for more natural movement
					var speedVariation = 0.8 + Math.random() * 0.4; // 0.8 to 1.2 speed multiplier
					self.x += waypointDx / waypointDistance * self.speed * speedVariation;
					self.y += waypointDy / waypointDistance * self.speed * speedVariation;
				} else {
					// Reached waypoint, move to next one
					self.currentWaypointIndex++;
				}
			} else {
				// Fallback to direct movement if no waypoints
				if (distance > 5) {
					self.x += dx / distance * self.speed;
					self.y += dy / distance * self.speed;
				}
			}
		} else if (self.isPatrolling) {
			// Outside red area - use patrol behavior
			// Move towards target patrol position
			var targetDx = self.targetX - self.x;
			var targetDy = self.targetY - self.y;
			var targetDistance = Math.sqrt(targetDx * targetDx + targetDy * targetDy);
			if (targetDistance > 5) {
				self.x += targetDx / targetDistance * self.speed;
				self.y += targetDy / targetDistance * self.speed;
			}
			// Update patrol duration
			self.patrolDuration--;
			if (self.patrolDuration <= 0) {
				self.isPatrolling = false;
			} else {
				// Update patrol timer for position changes
				self.patrolTimer--;
				if (self.patrolTimer <= 0) {
					// Choose new patrol position around red area border
					var angle = Math.random() * Math.PI * 2;
					var radius = player.range + 20; // Just outside red area
					self.targetX = player.x + Math.cos(angle) * radius;
					self.targetY = player.y + Math.sin(angle) * radius;
					// Keep patrol position within screen bounds
					self.targetX = Math.max(50, Math.min(1998, self.targetX));
					self.targetY = Math.max(50, Math.min(2682, self.targetY));
					// Set new patrol timer (1-5 seconds)
					self.patrolTimer = Math.floor(Math.random() * 240) + 60; // 60-300 frames (1-5 seconds)
				}
			}
		} else {
			// Outside red area and not patrolling - direct movement towards player
			if (distance > 5) {
				self.x += dx / distance * self.speed;
				self.y += dy / distance * self.speed;
			}
		}
		// Check collision with player
		if (self.lastPlayerDistance > 30 && distance <= 30 && !self.isPatrolling) {
			player.takeDamage(self.damage);
			LK.getSound('hit').play();
			// Add visual feedback with tween
			tween(self, {
				alpha: 0.5
			}, {
				duration: 200
			});
			tween(self, {
				alpha: 1
			}, {
				duration: 200,
				onFinish: function onFinish() {}
			});
			// Start patrolling after damaging player
			self.isPatrolling = true;
			self.patrolDuration = 180; // 3 seconds at 60 FPS
			var angle = Math.random() * Math.PI * 2;
			var radius = player.range + 20; // Just outside red area
			self.targetX = player.x + Math.cos(angle) * radius;
			self.targetY = player.y + Math.sin(angle) * radius;
			// Keep patrol position within screen bounds
			self.targetX = Math.max(50, Math.min(1998, self.targetX));
			self.targetY = Math.max(50, Math.min(2682, self.targetY));
			// Set patrol timer (1-5 seconds)
			self.patrolTimer = Math.floor(Math.random() * 240) + 60; // 60-300 frames (1-5 seconds)
		}
		self.lastPlayerDistance = distance;
	};
	self.takeDamage = function (damage) {
		self.health -= damage;
		if (self.healthText) {
			self.healthText.setText(Math.max(0, self.health).toString());
		}
		if (self.health <= 0) {
			self.die();
		}
	};
	self.die = function () {
		// Track total zombies killed
		totalZombiesKilled++;
		// Check if boss should spawn (every 30 kills)
		if (totalZombiesKilled - lastBossSpawn >= 30) {
			lastBossSpawn = totalZombiesKilled;
			// Spawn boss zombie5
			var boss = new Zombie5();
			var side = Math.floor(Math.random() * 4);
			switch (side) {
				case 0:
					// Top
					boss.x = Math.random() * 2048;
					boss.y = -50;
					break;
				case 1:
					// Right
					boss.x = 2098;
					boss.y = Math.random() * 2732;
					break;
				case 2:
					// Bottom
					boss.x = Math.random() * 2048;
					boss.y = 2782;
					break;
				case 3:
					// Left
					boss.x = -50;
					boss.y = Math.random() * 2732;
					break;
			}
			zombies.push(boss);
			game.addChild(boss);
		}
		// 10% chance to drop pistol weapon when zombie3 dies
		if (Math.random() < 0.1) {
			var weapon = new Weapon();
			weapon.x = self.x;
			weapon.y = self.y;
			weapons.push(weapon);
			game.addChild(weapon);
		}
		// Also drop coins
		var coin = new Coin();
		coin.x = self.x + 30; // Offset slightly to avoid overlap
		coin.y = self.y;
		coin.value = self.coinValue;
		coins.push(coin);
		game.addChild(coin);
		var index = zombies.indexOf(self);
		if (index !== -1) {
			zombies.splice(index, 1);
		}
		self.destroy();
	};
	return self;
});
var Zombie4 = Container.expand(function () {
	var self = Container.call(this);
	var zombieGraphics = self.attachAsset('zombie4', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.health = 250; // Highest health
	self.maxHealth = 250;
	self.speed = 5; // Very fast
	self.damage = 50; // Highest damage
	self.coinValue = 35; // Most coins when killed
	self.lastPlayerDistance = Infinity;
	self.isPatrolling = false;
	self.patrolTimer = 0;
	self.patrolDuration = 0;
	self.targetX = 0;
	self.targetY = 0;
	self.waypoints = [];
	self.currentWaypointIndex = 0;
	self.pathUpdateTimer = 0;
	self.lastPlayerX = 0;
	self.lastPlayerY = 0;
	// Create health text above zombie (cyan to match elite zombie)
	var healthText = new Text2(self.health.toString(), {
		size: 40,
		fill: 0x00FFFF
	});
	healthText.anchor.set(0.5, 1);
	healthText.x = 0;
	healthText.y = -80;
	self.addChild(healthText);
	self.healthText = healthText;
	self.update = function () {
		var dx = player.x - self.x;
		var dy = player.y - self.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		// Check if zombie is inside red area (player range)
		var insideRedArea = distance <= player.range;
		// If zombie enters red area while patrolling, stop patrolling and attack
		if (self.isPatrolling && insideRedArea) {
			self.isPatrolling = false;
		}
		if (insideRedArea) {
			// Inside red area - use AI pathfinding behavior
			self.pathUpdateTimer++;
			// Update path every 30 frames (0.5 seconds) or if player moved significantly
			var playerMoved = Math.abs(player.x - self.lastPlayerX) > 50 || Math.abs(player.y - self.lastPlayerY) > 50;
			if (self.pathUpdateTimer >= 30 || playerMoved || self.waypoints.length === 0) {
				self.pathUpdateTimer = 0;
				self.lastPlayerX = player.x;
				self.lastPlayerY = player.y;
				// Generate waypoints for AI movement
				self.waypoints = [];
				self.currentWaypointIndex = 0;
				// Create 2-4 waypoints between zombie and player
				var waypointCount = Math.floor(Math.random() * 3) + 2; // 2-4 waypoints
				var stepX = (player.x - self.x) / (waypointCount + 1);
				var stepY = (player.y - self.y) / (waypointCount + 1);
				for (var w = 1; w <= waypointCount; w++) {
					var baseX = self.x + stepX * w;
					var baseY = self.y + stepY * w;
					// Add random offset to create non-linear path
					var offsetRange = 150;
					var offsetX = (Math.random() - 0.5) * offsetRange;
					var offsetY = (Math.random() - 0.5) * offsetRange;
					var waypointX = Math.max(50, Math.min(1998, baseX + offsetX));
					var waypointY = Math.max(50, Math.min(2682, baseY + offsetY));
					self.waypoints.push({
						x: waypointX,
						y: waypointY
					});
				}
				// Add final waypoint near player
				self.waypoints.push({
					x: player.x,
					y: player.y
				});
			}
			// Move towards current waypoint
			if (self.waypoints.length > 0 && self.currentWaypointIndex < self.waypoints.length) {
				var currentWaypoint = self.waypoints[self.currentWaypointIndex];
				var waypointDx = currentWaypoint.x - self.x;
				var waypointDy = currentWaypoint.y - self.y;
				var waypointDistance = Math.sqrt(waypointDx * waypointDx + waypointDy * waypointDy);
				if (waypointDistance > 20) {
					// Move towards waypoint with slight speed variation for more natural movement
					var speedVariation = 0.8 + Math.random() * 0.4; // 0.8 to 1.2 speed multiplier
					self.x += waypointDx / waypointDistance * self.speed * speedVariation;
					self.y += waypointDy / waypointDistance * self.speed * speedVariation;
				} else {
					// Reached waypoint, move to next one
					self.currentWaypointIndex++;
				}
			} else {
				// Fallback to direct movement if no waypoints
				if (distance > 5) {
					self.x += dx / distance * self.speed;
					self.y += dy / distance * self.speed;
				}
			}
		} else if (self.isPatrolling) {
			// Outside red area - use patrol behavior
			// Move towards target patrol position
			var targetDx = self.targetX - self.x;
			var targetDy = self.targetY - self.y;
			var targetDistance = Math.sqrt(targetDx * targetDx + targetDy * targetDy);
			if (targetDistance > 5) {
				self.x += targetDx / targetDistance * self.speed;
				self.y += targetDy / targetDistance * self.speed;
			}
			// Update patrol duration
			self.patrolDuration--;
			if (self.patrolDuration <= 0) {
				self.isPatrolling = false;
			} else {
				// Update patrol timer for position changes
				self.patrolTimer--;
				if (self.patrolTimer <= 0) {
					// Choose new patrol position around red area border
					var angle = Math.random() * Math.PI * 2;
					var radius = player.range + 20; // Just outside red area
					self.targetX = player.x + Math.cos(angle) * radius;
					self.targetY = player.y + Math.sin(angle) * radius;
					// Keep patrol position within screen bounds
					self.targetX = Math.max(50, Math.min(1998, self.targetX));
					self.targetY = Math.max(50, Math.min(2682, self.targetY));
					// Set new patrol timer (1-5 seconds)
					self.patrolTimer = Math.floor(Math.random() * 240) + 60; // 60-300 frames (1-5 seconds)
				}
			}
		} else {
			// Outside red area and not patrolling - direct movement towards player
			if (distance > 5) {
				self.x += dx / distance * self.speed;
				self.y += dy / distance * self.speed;
			}
		}
		// Check collision with player
		if (self.lastPlayerDistance > 30 && distance <= 30 && !self.isPatrolling) {
			player.takeDamage(self.damage);
			LK.getSound('hit').play();
			// Add visual feedback with tween
			tween(self, {
				alpha: 0.5
			}, {
				duration: 200
			});
			tween(self, {
				alpha: 1
			}, {
				duration: 200,
				onFinish: function onFinish() {}
			});
			// Start patrolling after damaging player
			self.isPatrolling = true;
			self.patrolDuration = 180; // 3 seconds at 60 FPS
			var angle = Math.random() * Math.PI * 2;
			var radius = player.range + 20; // Just outside red area
			self.targetX = player.x + Math.cos(angle) * radius;
			self.targetY = player.y + Math.sin(angle) * radius;
			// Keep patrol position within screen bounds
			self.targetX = Math.max(50, Math.min(1998, self.targetX));
			self.targetY = Math.max(50, Math.min(2682, self.targetY));
			// Set patrol timer (1-5 seconds)
			self.patrolTimer = Math.floor(Math.random() * 240) + 60; // 60-300 frames (1-5 seconds)
		}
		self.lastPlayerDistance = distance;
	};
	self.takeDamage = function (damage) {
		self.health -= damage;
		if (self.healthText) {
			self.healthText.setText(Math.max(0, self.health).toString());
		}
		if (self.health <= 0) {
			self.die();
		}
	};
	self.die = function () {
		// Track total zombies killed
		totalZombiesKilled++;
		// Check if boss should spawn (every 30 kills)
		if (totalZombiesKilled - lastBossSpawn >= 30) {
			lastBossSpawn = totalZombiesKilled;
			// Spawn boss zombie5
			var boss = new Zombie5();
			var side = Math.floor(Math.random() * 4);
			switch (side) {
				case 0:
					// Top
					boss.x = Math.random() * 2048;
					boss.y = -50;
					break;
				case 1:
					// Right
					boss.x = 2098;
					boss.y = Math.random() * 2732;
					break;
				case 2:
					// Bottom
					boss.x = Math.random() * 2048;
					boss.y = 2782;
					break;
				case 3:
					// Left
					boss.x = -50;
					boss.y = Math.random() * 2732;
					break;
			}
			zombies.push(boss);
			game.addChild(boss);
		}
		// 10% chance to drop pistol weapon when zombie4 dies
		if (Math.random() < 0.1) {
			var weapon = new Weapon();
			weapon.x = self.x;
			weapon.y = self.y;
			weapons.push(weapon);
			game.addChild(weapon);
		}
		// Also drop coins
		var coin = new Coin();
		coin.x = self.x + 30; // Offset slightly to avoid overlap
		coin.y = self.y;
		coin.value = self.coinValue;
		coins.push(coin);
		game.addChild(coin);
		var index = zombies.indexOf(self);
		if (index !== -1) {
			zombies.splice(index, 1);
		}
		self.destroy();
	};
	return self;
});
var Zombie5 = Container.expand(function () {
	var self = Container.call(this);
	var zombieGraphics = self.attachAsset('zombie5', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.health = 10000; // Boss health
	self.maxHealth = 10000;
	self.speed = 3; // Moderate speed for boss
	self.damage = 75; // High damage
	self.coinValue = 50; // High coin value
	self.lastPlayerDistance = Infinity;
	self.isPatrolling = false;
	self.patrolTimer = 0;
	self.patrolDuration = 0;
	self.targetX = 0;
	self.targetY = 0;
	self.waypoints = [];
	self.currentWaypointIndex = 0;
	self.pathUpdateTimer = 0;
	self.lastPlayerX = 0;
	self.lastPlayerY = 0;
	self.shootingRange = 600; // Zombie5 shooting range - increased for better long-range combat
	// Create health text above boss zombie (gold to show it's a boss)
	var healthText = new Text2(self.health.toString(), {
		size: 50,
		fill: 0xFFD700
	});
	healthText.anchor.set(0.5, 1);
	healthText.x = 0;
	healthText.y = -100;
	self.addChild(healthText);
	self.healthText = healthText;
	self.update = function () {
		var dx = player.x - self.x;
		var dy = player.y - self.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		// Check if zombie is inside red area (player range)
		var insideRedArea = distance <= player.range;
		// If zombie enters red area while patrolling, stop patrolling and attack
		if (self.isPatrolling && insideRedArea) {
			self.isPatrolling = false;
		}
		if (insideRedArea) {
			// Inside red area - use AI pathfinding behavior
			self.pathUpdateTimer++;
			// Update path every 30 frames (0.5 seconds) or if player moved significantly
			var playerMoved = Math.abs(player.x - self.lastPlayerX) > 50 || Math.abs(player.y - self.lastPlayerY) > 50;
			if (self.pathUpdateTimer >= 30 || playerMoved || self.waypoints.length === 0) {
				self.pathUpdateTimer = 0;
				self.lastPlayerX = player.x;
				self.lastPlayerY = player.y;
				// Generate waypoints for AI movement
				self.waypoints = [];
				self.currentWaypointIndex = 0;
				// Create 2-4 waypoints between zombie and player
				var waypointCount = Math.floor(Math.random() * 3) + 2; // 2-4 waypoints
				var stepX = (player.x - self.x) / (waypointCount + 1);
				var stepY = (player.y - self.y) / (waypointCount + 1);
				for (var w = 1; w <= waypointCount; w++) {
					var baseX = self.x + stepX * w;
					var baseY = self.y + stepY * w;
					// Add random offset to create non-linear path
					var offsetRange = 150;
					var offsetX = (Math.random() - 0.5) * offsetRange;
					var offsetY = (Math.random() - 0.5) * offsetRange;
					var waypointX = Math.max(50, Math.min(1998, baseX + offsetX));
					var waypointY = Math.max(50, Math.min(2682, baseY + offsetY));
					self.waypoints.push({
						x: waypointX,
						y: waypointY
					});
				}
				// Add final waypoint near player
				self.waypoints.push({
					x: player.x,
					y: player.y
				});
			}
			// Move towards current waypoint
			if (self.waypoints.length > 0 && self.currentWaypointIndex < self.waypoints.length) {
				var currentWaypoint = self.waypoints[self.currentWaypointIndex];
				var waypointDx = currentWaypoint.x - self.x;
				var waypointDy = currentWaypoint.y - self.y;
				var waypointDistance = Math.sqrt(waypointDx * waypointDx + waypointDy * waypointDy);
				if (waypointDistance > 20) {
					// Move towards waypoint with slight speed variation for more natural movement
					var speedVariation = 0.8 + Math.random() * 0.4; // 0.8 to 1.2 speed multiplier
					self.x += waypointDx / waypointDistance * self.speed * speedVariation;
					self.y += waypointDy / waypointDistance * self.speed * speedVariation;
				} else {
					// Reached waypoint, move to next one
					self.currentWaypointIndex++;
				}
			} else {
				// Fallback to direct movement if no waypoints
				if (distance > 5) {
					self.x += dx / distance * self.speed;
					self.y += dy / distance * self.speed;
				}
			}
		} else if (self.isPatrolling) {
			// Outside red area - use patrol behavior
			// Move towards target patrol position
			var targetDx = self.targetX - self.x;
			var targetDy = self.targetY - self.y;
			var targetDistance = Math.sqrt(targetDx * targetDx + targetDy * targetDy);
			if (targetDistance > 5) {
				self.x += targetDx / targetDistance * self.speed;
				self.y += targetDy / targetDistance * self.speed;
			}
			// Update patrol duration
			self.patrolDuration--;
			if (self.patrolDuration <= 0) {
				self.isPatrolling = false;
			} else {
				// Update patrol timer for position changes
				self.patrolTimer--;
				if (self.patrolTimer <= 0) {
					// Choose new patrol position around red area border
					var angle = Math.random() * Math.PI * 2;
					var radius = player.range + 20; // Just outside red area
					self.targetX = player.x + Math.cos(angle) * radius;
					self.targetY = player.y + Math.sin(angle) * radius;
					// Keep patrol position within screen bounds
					self.targetX = Math.max(50, Math.min(1998, self.targetX));
					self.targetY = Math.max(50, Math.min(2682, self.targetY));
					// Set new patrol timer (1-5 seconds)
					self.patrolTimer = Math.floor(Math.random() * 240) + 60; // 60-300 frames (1-5 seconds)
				}
			}
		} else {
			// Outside red area and not patrolling - direct movement towards player
			if (distance > 5) {
				self.x += dx / distance * self.speed;
				self.y += dy / distance * self.speed;
			}
		}
		// Boss shooting behavior - shoot every 3 seconds when player is within range
		if (!self.shootTimer) self.shootTimer = 0;
		self.shootTimer++;
		if (self.shootTimer >= 180) {
			// Shoot every 3 seconds (180 frames at 60fps)
			self.shootTimer = 0;
			// Check if player is within shooting range
			var playerDistance = Math.sqrt(dx * dx + dy * dy);
			if (playerDistance <= self.shootingRange) {
				// Create zombie bullet aimed at player
				var zombieBullet = new ZombieBullet();
				zombieBullet.x = self.x;
				zombieBullet.y = self.y;
				// Calculate direction to player with slight prediction
				var bulletDx = player.x - self.x;
				var bulletDy = player.y - self.y;
				var bulletDistance = Math.sqrt(bulletDx * bulletDx + bulletDy * bulletDy);
				// Add slight aim prediction if player is moving
				if (playerIsMoving) {
					var playerVelX = player.x - playerLastX;
					var playerVelY = player.y - playerLastY;
					var timeToTarget = bulletDistance / zombieBullet.speed;
					bulletDx += playerVelX * timeToTarget * 0.5;
					bulletDy += playerVelY * timeToTarget * 0.5;
					bulletDistance = Math.sqrt(bulletDx * bulletDx + bulletDy * bulletDy);
				}
				// Set bullet velocity toward predicted player position
				zombieBullet.velocityX = bulletDx / bulletDistance * zombieBullet.speed;
				zombieBullet.velocityY = bulletDy / bulletDistance * zombieBullet.speed;
				zombieBullets.push(zombieBullet);
				game.addChild(zombieBullet);
				LK.getSound('shoot').play();
			}
		}
		// Boss only attacks with bullets - no melee damage
		// Remove melee collision behavior to make boss ranged-only
		self.lastPlayerDistance = distance;
	};
	self.takeDamage = function (damage) {
		// Prevent one-hit kills from both bullets and punches
		// Cap all damage to reasonable amounts for boss fights
		var actualDamage = damage;
		if (damage === 25) {
			// This is a punch attack, limit damage significantly
			actualDamage = Math.min(damage, 50); // Cap punch damage at 50 for boss
		} else if (damage === 100) {
			// This is a bullet attack, limit damage to prevent one-hit kills
			actualDamage = Math.min(damage, 200); // Cap bullet damage at 200 for boss
		} else {
			// Any other damage source, cap at reasonable amount
			actualDamage = Math.min(damage, 200);
		}
		self.health -= actualDamage;
		if (self.healthText) {
			self.healthText.setText(Math.max(0, self.health).toString());
		}
		if (self.health <= 0) {
			self.die();
		}
	};
	self.die = function () {
		// Boss always drops pistol weapon
		var weapon = new Weapon();
		weapon.x = self.x;
		weapon.y = self.y;
		weapons.push(weapon);
		game.addChild(weapon);
		// Also drop coins
		var coin = new Coin();
		coin.x = self.x + 30; // Offset slightly to avoid overlap
		coin.y = self.y;
		coin.value = self.coinValue;
		coins.push(coin);
		game.addChild(coin);
		var index = zombies.indexOf(self);
		if (index !== -1) {
			zombies.splice(index, 1);
		}
		self.destroy();
	};
	return self;
});
var ZombieBullet = Container.expand(function () {
	var self = Container.call(this);
	var bulletGraphics = self.attachAsset('bullet', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Tint the bullet red to show it's from zombies
	bulletGraphics.tint = 0xFF0000;
	self.velocityX = 0;
	self.velocityY = 0;
	self.damage = 15;
	self.speed = 12;
	self.zombieType = 'zombie5'; // Track which zombie type shot this bullet
	self.update = function () {
		// Move bullet with constant velocity
		self.x += self.velocityX;
		self.y += self.velocityY;
		// Remove if off screen
		if (self.x < -50 || self.x > 2098 || self.y < -50 || self.y > 2782) {
			var index = zombieBullets.indexOf(self);
			if (index !== -1) {
				zombieBullets.splice(index, 1);
			}
			self.destroy();
		}
	};
	return self;
});

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

/**** 
* Game Code
****/ 
// Game state
var gameStarted = false;
var bulletCount = 10;
var maxBullets = 10;
var isReloading = false;
var reloadTimer = 0;
var fireButtonActive = false;
var bulletsFired = 0;
var instantKillBullets = [];
var pistolBulletsFired = 0; // Track bullets fired with pistol
// Survival tracking
var gameStartTime = 0;
var survivalTime = 0;
// Player movement tracking
var playerLastX = 0;
var playerLastY = 0;
var playerIsMoving = false;
// Start menu elements
var titleText = new Text2('ZOMBIE SURVIVAL', {
	size: 80,
	fill: 0xFFFFFF
});
titleText.anchor.set(0.5, 0.5);
LK.gui.center.addChild(titleText);
titleText.y = -200;
var playButton = new Text2('TAP TO START', {
	size: 60,
	fill: 0x00FF00
});
playButton.anchor.set(0.5, 0.5);
LK.gui.center.addChild(playButton);
playButton.y = 100;
// Game arrays
var zombies = [];
var bullets = [];
var coins = [];
var healthDrops = [];
var weapons = [];
var zombieBullets = [];
// Game variables
var waveNumber = 1;
var zombiesPerWave = 5;
var spawnTimer = 0;
var zombiesSpawned = 0;
var totalZombiesKilled = 0;
var lastBossSpawn = 0;
var healthRegenTimer = 0; // Timer for health regeneration every 3 seconds (180 frames at 60fps)
// Player variable (will be created when game starts)
var player = null;
// UI Elements (will be created when game starts)
var healthText = null;
var coinsText = null;
var waveText = null;
var bulletText = null;
var weaponText = null;
var bossCountdownText = null;
var bossHealthText = null;
var healthRegenText = null;
function startGame() {
	gameStarted = true;
	// Set game start time for survival tracking
	gameStartTime = Date.now();
	// Hide start menu
	titleText.visible = false;
	playButton.visible = false;
	// Add background image
	var backgroundImage = game.attachAsset('background', {
		anchorX: 0,
		anchorY: 0,
		x: 0,
		y: 0
	});
	// Make sure background is behind everything else
	game.setChildIndex(backgroundImage, 0);
	// Create player
	player = game.addChild(new Player());
	player.x = 1024;
	player.y = 1366;
	// Load coins from storage
	player.coins = storage.coins || 0;
	// Create UI Elements
	healthText = new Text2('Health: 100/100', {
		size: 40,
		fill: 0xFF0000
	});
	healthText.anchor.set(0, 0);
	LK.gui.topLeft.addChild(healthText);
	healthText.x = 120;
	healthText.y = 20;
	coinsText = new Text2('Coins: 0', {
		size: 40,
		fill: 0xFFD700
	});
	coinsText.anchor.set(0, 0);
	LK.gui.topRight.addChild(coinsText);
	coinsText.x = -200;
	coinsText.y = 20;
	waveText = new Text2('Wave: 1 (5 zombies)', {
		size: 40,
		fill: 0xFFFFFF
	});
	waveText.anchor.set(0.5, 0);
	LK.gui.top.addChild(waveText);
	waveText.y = 20;
	bulletText = new Text2('', {
		size: 40,
		fill: 0x00FFFF
	});
	bulletText.anchor.set(0.5, 0);
	player.addChild(bulletText);
	bulletText.x = 0;
	bulletText.y = 120;
	weaponText = new Text2('Weapon: Fists', {
		size: 35,
		fill: 0xFFFF00
	});
	weaponText.anchor.set(0.5, 0);
	player.addChild(weaponText);
	weaponText.x = 0;
	weaponText.y = 160;
	bossCountdownText = new Text2('Boss in: 30 kills', {
		size: 45,
		fill: 0xFF4444
	});
	bossCountdownText.anchor.set(0.5, 0);
	LK.gui.top.addChild(bossCountdownText);
	bossCountdownText.y = 80;
	bossHealthText = new Text2('', {
		size: 55,
		fill: 0xFFD700
	});
	bossHealthText.anchor.set(0.5, 0);
	LK.gui.top.addChild(bossHealthText);
	bossHealthText.y = 140;
	bossHealthText.visible = true;
	healthRegenText = new Text2('Health +1 in: 3s', {
		size: 35,
		fill: 0x00FF88
	});
	healthRegenText.anchor.set(0, 0);
	LK.gui.topLeft.addChild(healthRegenText);
	healthRegenText.x = 120;
	healthRegenText.y = 70;
}
function showDeathStats() {
	// Calculate survival time in minutes and seconds
	var totalSeconds = Math.floor(survivalTime / 1000);
	var minutes = Math.floor(totalSeconds / 60);
	var seconds = totalSeconds % 60;
	var timeString = minutes + "m " + seconds + "s";
	// Save best stats to storage
	var bestZombiesKilled = storage.bestZombiesKilled || 0;
	var bestSurvivalTime = storage.bestSurvivalTime || 0;
	var isNewZombieRecord = totalZombiesKilled > bestZombiesKilled;
	var isNewTimeRecord = survivalTime > bestSurvivalTime;
	if (isNewZombieRecord) {
		storage.bestZombiesKilled = totalZombiesKilled;
	}
	if (isNewTimeRecord) {
		storage.bestSurvivalTime = survivalTime;
	}
	// Create death stats overlay
	var statsOverlay = new Container();
	game.addChild(statsOverlay);
	// Semi-transparent background
	var bgShape = LK.getAsset('background', {
		anchorX: 0,
		anchorY: 0,
		x: 0,
		y: 0,
		alpha: 0.8,
		tint: 0x000000
	});
	statsOverlay.addChild(bgShape);
	// Death title
	var deathTitle = new Text2('GAME OVER', {
		size: 100,
		fill: 0xFF0000
	});
	deathTitle.anchor.set(0.5, 0.5);
	deathTitle.x = 1024;
	deathTitle.y = 800;
	statsOverlay.addChild(deathTitle);
	// Zombies killed stat
	var zombiesText = new Text2('Zombies Killed: ' + totalZombiesKilled, {
		size: 60,
		fill: isNewZombieRecord ? 0x00FF00 : 0xFFFFFF
	});
	zombiesText.anchor.set(0.5, 0.5);
	zombiesText.x = 1024;
	zombiesText.y = 950;
	statsOverlay.addChild(zombiesText);
	// Survival time stat
	var timeText = new Text2('Survival Time: ' + timeString, {
		size: 60,
		fill: isNewTimeRecord ? 0x00FF00 : 0xFFFFFF
	});
	timeText.anchor.set(0.5, 0.5);
	timeText.x = 1024;
	timeText.y = 1020;
	statsOverlay.addChild(timeText);
	// Best records
	if (bestZombiesKilled > 0) {
		var bestZombiesText = new Text2('Best Zombies: ' + Math.max(bestZombiesKilled, totalZombiesKilled), {
			size: 45,
			fill: 0xFFD700
		});
		bestZombiesText.anchor.set(0.5, 0.5);
		bestZombiesText.x = 1024;
		bestZombiesText.y = 1120;
		statsOverlay.addChild(bestZombiesText);
	}
	if (bestSurvivalTime > 0) {
		var bestTimeSeconds = Math.floor(Math.max(bestSurvivalTime, survivalTime) / 1000);
		var bestMinutes = Math.floor(bestTimeSeconds / 60);
		var bestSecondsRemaining = bestTimeSeconds % 60;
		var bestTimeString = bestMinutes + "m " + bestSecondsRemaining + "s";
		var bestTimeText = new Text2('Best Time: ' + bestTimeString, {
			size: 45,
			fill: 0xFFD700
		});
		bestTimeText.anchor.set(0.5, 0.5);
		bestTimeText.x = 1024;
		bestTimeText.y = 1180;
		statsOverlay.addChild(bestTimeText);
	}
	// New record indicators
	if (isNewZombieRecord) {
		var newRecordText1 = new Text2('NEW RECORD!', {
			size: 40,
			fill: 0x00FF00
		});
		newRecordText1.anchor.set(0.5, 0.5);
		newRecordText1.x = 1400;
		newRecordText1.y = 950;
		statsOverlay.addChild(newRecordText1);
	}
	if (isNewTimeRecord) {
		var newRecordText2 = new Text2('NEW RECORD!', {
			size: 40,
			fill: 0x00FF00
		});
		newRecordText2.anchor.set(0.5, 0.5);
		newRecordText2.x = 1400;
		newRecordText2.y = 1020;
		statsOverlay.addChild(newRecordText2);
	}
	// Continue instruction
	var continueText = new Text2('Tap to continue...', {
		size: 50,
		fill: 0xCCCCCC
	});
	continueText.anchor.set(0.5, 0.5);
	continueText.x = 1024;
	continueText.y = 1300;
	statsOverlay.addChild(continueText);
	// Add pulsing effect to continue text
	tween(continueText, {
		alpha: 0.3
	}, {
		duration: 1000,
		easing: tween.easeInOut,
		loop: true,
		yoyo: true
	});
	// Wait for tap then show game over
	LK.setTimeout(function () {
		game.down = function (x, y, obj) {
			statsOverlay.destroy();
			LK.showGameOver();
		};
	}, 500);
}
// Touch controls
var touchStartX = 0;
var touchStartY = 0;
var isMoving = false;
game.down = function (x, y, obj) {
	if (!gameStarted) {
		startGame();
		return;
	}
	touchStartX = x;
	touchStartY = y;
	isMoving = true;
	// Shoot at nearest zombie or forward if no zombies
	if (player && bulletCount > 0 && !isReloading) {
		// Find nearest zombie within range as target
		var nearestZombie = null;
		var minDistance = Infinity;
		for (var i = 0; i < zombies.length; i++) {
			var zombie = zombies[i];
			var dx = zombie.x - player.x;
			var dy = zombie.y - player.y;
			var distance = Math.sqrt(dx * dx + dy * dy);
			if (distance <= player.range && distance < minDistance) {
				minDistance = distance;
				nearestZombie = zombie;
			}
		}
		// Shoot at nearest zombie within range only
		if (nearestZombie) {
			player.shoot(nearestZombie.x, nearestZombie.y);
		}
	}
};
game.move = function (x, y, obj) {
	if (!gameStarted || !player) return;
	if (isMoving) {
		var dx = x - touchStartX;
		var dy = y - touchStartY;
		var newX = player.x + dx * 0.5;
		var newY = player.y + dy * 0.5;
		// Keep player within bounds
		player.x = Math.max(30, Math.min(2018, newX));
		player.y = Math.max(30, Math.min(2702, newY));
		touchStartX = x;
		touchStartY = y;
	}
};
game.up = function (x, y, obj) {
	if (!gameStarted) return;
	isMoving = false;
};
// Game update loop
game.update = function () {
	if (!gameStarted || !player) return;
	// Update survival time
	survivalTime = Date.now() - gameStartTime;
	// Track player movement
	if (playerLastX === 0 && playerLastY === 0) {
		playerLastX = player.x;
		playerLastY = player.y;
	}
	var playerMoved = Math.abs(player.x - playerLastX) > 2 || Math.abs(player.y - playerLastY) > 2;
	playerIsMoving = playerMoved;
	playerLastX = player.x;
	playerLastY = player.y;
	// Handle reloading
	if (isReloading) {
		reloadTimer--;
		if (reloadTimer <= 0) {
			bulletCount = maxBullets;
			isReloading = false;
		}
	}
	// Health regeneration system - every 3 seconds (180 frames at 60fps)
	healthRegenTimer++;
	if (healthRegenTimer >= 180) {
		healthRegenTimer = 0;
		// Increase player health by 1 every 3 seconds
		player.health += 1;
		// Update max health if current health exceeds it
		if (player.health > player.maxHealth) {
			player.maxHealth = player.health;
		}
		// Update health text display
		if (player.healthText) {
			player.healthText.setText(player.health.toString());
		}
	}
	// Update UI
	if (healthText && coinsText && waveText && bulletText && weaponText && bossCountdownText && bossHealthText && healthRegenText) {
		healthText.setText('Health: ' + player.health + '/' + player.maxHealth);
		coinsText.setText('Coins: ' + player.coins);
		var remainingZombies = zombiesPerWave - zombiesSpawned + zombies.length;
		waveText.setText('Wave: ' + waveNumber + ' (' + remainingZombies + ' zombies)');
		// Update health regeneration countdown display
		var regenTimeLeft = Math.ceil((180 - healthRegenTimer) / 60);
		healthRegenText.setText('Health +1 in: ' + regenTimeLeft + 's');
		if (isReloading) {
			var reloadTimeLeft = Math.ceil(reloadTimer / 60);
			bulletText.setText('Reloading... ' + reloadTimeLeft + 's');
		} else {
			bulletText.setText('Bullets: ' + bulletCount + '/' + maxBullets);
		}
		var weaponDisplay = player.hasWeapon ? player.weaponType.charAt(0).toUpperCase() + player.weaponType.slice(1) + ' (DMG:' + player.weaponDamage + ')' : 'Fists (DMG:' + player.damage + ')';
		weaponText.setText('Weapon: ' + weaponDisplay);
		// Check if boss is alive and update boss health display
		var bossAlive = false;
		for (var bossIndex = 0; bossIndex < zombies.length; bossIndex++) {
			var zombie = zombies[bossIndex];
			if (zombie.health === 10000 || zombie.maxHealth === 10000) {
				// This is a boss (Zombie5)
				bossAlive = true;
				bossHealthText.setText('BOSS HEALTH: ' + zombie.health + '/' + zombie.maxHealth);
				break;
			}
		}
		if (!bossAlive) {
			bossHealthText.setText('BOSS HEALTH: 10000/10000');
		}
		// Boss health display is always visible
		bossHealthText.visible = true;
		// Update boss countdown
		var killsUntilBoss = 30 - (totalZombiesKilled - lastBossSpawn);
		if (killsUntilBoss <= 0) {
			bossCountdownText.setText('BOSS INCOMING!');
			bossCountdownText.fill = 0xFF0000;
			// Add pulsing effect when boss is ready
			var pulseScale = 1 + Math.sin(LK.ticks * 0.2) * 0.2;
			bossCountdownText.scaleX = pulseScale;
			bossCountdownText.scaleY = pulseScale;
		} else {
			bossCountdownText.setText('Boss in: ' + killsUntilBoss + ' kills');
			bossCountdownText.fill = 0xFF4444;
			bossCountdownText.scaleX = 1;
			bossCountdownText.scaleY = 1;
		}
	}
	// Spawn zombies
	if (zombiesSpawned < zombiesPerWave) {
		spawnTimer++;
		if (spawnTimer >= 60) {
			// Spawn every second
			spawnTimer = 0;
			spawnZombie();
			zombiesSpawned++;
		}
	} else if (zombies.length === 0) {
		// Start next wave
		waveNumber++;
		zombiesPerWave += 2;
		zombiesSpawned = 0;
	}
	// Check bullet-zombie collisions
	for (var i = bullets.length - 1; i >= 0; i--) {
		var bullet = bullets[i];
		var bulletHit = false;
		for (var j = zombies.length - 1; j >= 0; j--) {
			var zombie = zombies[j];
			if (bullet.intersects(zombie)) {
				if (bullet.isInstantKill) {
					// Instant kill bullet
					zombie.takeDamage(zombie.health);
				} else {
					// Use bullet's exact damage (100 for regular bullets)
					zombie.takeDamage(bullet.damage);
				}
				bullets.splice(i, 1);
				bullet.destroy();
				bulletHit = true;
				break;
			}
		}
	}
	// Check zombie bullet-player collisions
	for (var k = zombieBullets.length - 1; k >= 0; k--) {
		var zombieBullet = zombieBullets[k];
		var hitPlayer = false;
		// Check collision with player
		if (zombieBullet.intersects(player)) {
			// Only apply damage if bullet is from zombie5
			if (zombieBullet.zombieType === 'zombie5') {
				player.takeDamage(zombieBullet.damage);
				LK.getSound('hit').play();
			}
			hitPlayer = true;
		}
		// Check collision with playerPistol graphics if player has pistol
		if (!hitPlayer && player.hasWeapon && player.weaponType === 'pistol') {
			// Get the player's current graphics bounds for collision detection
			var playerBounds = player.getBounds();
			var bulletBounds = zombieBullet.getBounds();
			// Check if bullet overlaps with player bounds
			if (bulletBounds.x < playerBounds.x + playerBounds.width && bulletBounds.x + bulletBounds.width > playerBounds.x && bulletBounds.y < playerBounds.y + playerBounds.height && bulletBounds.y + bulletBounds.height > playerBounds.y) {
				// Only apply damage if bullet is from zombie5
				if (zombieBullet.zombieType === 'zombie5') {
					player.takeDamage(zombieBullet.damage);
					LK.getSound('hit').play();
				}
				hitPlayer = true;
			}
		}
		if (hitPlayer) {
			zombieBullets.splice(k, 1);
			zombieBullet.destroy();
		}
	}
};
function spawnZombie() {
	// Randomly spawn zombies with different probabilities
	var rand = Math.random();
	var zombie;
	if (rand < 0.15) {
		// 15% chance for zombie4 (elite)
		zombie = new Zombie4();
	} else if (rand < 0.35) {
		// 20% chance for zombie3 (strongest)
		zombie = new Zombie3();
	} else if (rand < 0.65) {
		// 30% chance for zombie2 (medium strength)
		zombie = new Zombie2();
	} else {
		// 35% chance for regular zombie (weakest)
		zombie = new Zombie();
	}
	// Spawn at random edge of screen
	var side = Math.floor(Math.random() * 4);
	switch (side) {
		case 0:
			// Top
			zombie.x = Math.random() * 2048;
			zombie.y = -50;
			break;
		case 1:
			// Right
			zombie.x = 2098;
			zombie.y = Math.random() * 2732;
			break;
		case 2:
			// Bottom
			zombie.x = Math.random() * 2048;
			zombie.y = 2782;
			break;
		case 3:
			// Left
			zombie.x = -50;
			zombie.y = Math.random() * 2732;
			break;
	}
	zombie.health += (waveNumber - 1) * 10; // Increase health with waves
	zombie.maxHealth = zombie.health;
	zombie.coinValue += Math.floor((waveNumber - 1) * 2);
	// Update health text to show new health value
	if (zombie.healthText) {
		zombie.healthText.setText(zombie.health.toString());
	}
	zombies.push(zombie);
	game.addChild(zombie);
}