/**** * 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); }