/**** 
* Plugins
****/ 
var tween = LK.import("@upit/tween.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 = 25;
	self.update = function () {
		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 = 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;
			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 10% of max health
			var healAmount = Math.floor(player.maxHealth * 0.1);
			player.health = Math.min(player.maxHealth, player.health + healAmount);
			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;
});
// 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;
	// 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;
			LK.showGameOver();
		}
	};
	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 = new Bullet();
		bullet.x = self.x;
		bullet.y = self.y;
		bullet.velocityX = dx / distance * 15;
		bullet.velocityY = dy / distance * 15;
		bullet.damage = self.damage;
		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 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.isRetreating = false;
	// 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);
		// If zombie is in retreat mode, move away from player
		if (self.isRetreating) {
			if (distance < player.range) {
				// Move away from player
				self.x -= dx / distance * self.speed * 1.5;
				self.y -= dy / distance * self.speed * 1.5;
			} else {
				// Exit red area, stop retreating and start attacking again
				self.isRetreating = false;
			}
		} else {
			// Normal attack behavior
			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.isRetreating) {
			player.takeDamage(self.damage);
			LK.getSound('hit').play();
			// Start retreating after dealing damage
			self.isRetreating = true;
			// Add visual feedback with tween
			tween(self, {
				alpha: 0.5
			}, {
				duration: 200
			});
			tween(self, {
				alpha: 1
			}, {
				duration: 200,
				onFinish: function onFinish() {}
			});
		}
		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 () {
		// If player health is not 100, 75% chance to drop health, otherwise drop coin
		// If player health is 100, 3% chance to drop health, otherwise drop coin
		var healthDropChance = player.health < 100 ? 0.75 : 0.03;
		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;
});

/**** 
* 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;
// 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 = [];
// Game variables
var waveNumber = 1;
var zombiesPerWave = 5;
var spawnTimer = 0;
var zombiesSpawned = 0;
// 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;
function startGame() {
	gameStarted = true;
	// Hide start menu
	titleText.visible = false;
	playButton.visible = false;
	// Create player
	player = game.addChild(new Player());
	player.x = 1024;
	player.y = 1366;
	// 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', {
		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;
}
// 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;
	// Handle reloading
	if (isReloading) {
		reloadTimer--;
		if (reloadTimer <= 0) {
			bulletCount = maxBullets;
			isReloading = false;
		}
	}
	// Update UI
	if (healthText && coinsText && waveText && bulletText) {
		healthText.setText('Health: ' + player.health + '/' + player.maxHealth);
		coinsText.setText('Coins: ' + player.coins);
		waveText.setText('Wave: ' + waveNumber);
		if (isReloading) {
			var reloadTimeLeft = Math.ceil(reloadTimer / 60);
			bulletText.setText('Reloading... ' + reloadTimeLeft + 's');
		} else {
			bulletText.setText('Bullets: ' + bulletCount + '/' + maxBullets);
		}
	}
	// 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)) {
				var randomDamage;
				// If this is the last bullet (bulletCount is 0), deal maximum damage
				if (bulletCount === 0) {
					randomDamage = zombie.health; // Guaranteed kill
				} else {
					// Random damage between 1 and zombie's current health (can kill in one shot)
					randomDamage = Math.floor(Math.random() * zombie.health) + 1;
				}
				zombie.takeDamage(randomDamage);
				bullets.splice(i, 1);
				bullet.destroy();
				bulletHit = true;
				break;
			}
		}
	}
};
function spawnZombie() {
	var 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);
}

===================================================================
--- original.js
+++ change.js
@@ -216,8 +216,9 @@
 	self.speed = 2;
 	self.damage = 20;
 	self.coinValue = 10;
 	self.lastPlayerDistance = Infinity;
+	self.isRetreating = false;
 	// Create health text above zombie
 	var healthText = new Text2(self.health.toString(), {
 		size: 40,
 		fill: 0xFF0000
@@ -230,16 +231,43 @@
 	self.update = function () {
 		var dx = player.x - self.x;
 		var dy = player.y - self.y;
 		var distance = Math.sqrt(dx * dx + dy * dy);
-		if (distance > 5) {
-			self.x += dx / distance * self.speed;
-			self.y += dy / distance * self.speed;
+		// If zombie is in retreat mode, move away from player
+		if (self.isRetreating) {
+			if (distance < player.range) {
+				// Move away from player
+				self.x -= dx / distance * self.speed * 1.5;
+				self.y -= dy / distance * self.speed * 1.5;
+			} else {
+				// Exit red area, stop retreating and start attacking again
+				self.isRetreating = false;
+			}
+		} else {
+			// Normal attack behavior
+			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) {
+		if (self.lastPlayerDistance > 30 && distance <= 30 && !self.isRetreating) {
 			player.takeDamage(self.damage);
 			LK.getSound('hit').play();
+			// Start retreating after dealing damage
+			self.isRetreating = true;
+			// Add visual feedback with tween
+			tween(self, {
+				alpha: 0.5
+			}, {
+				duration: 200
+			});
+			tween(self, {
+				alpha: 1
+			}, {
+				duration: 200,
+				onFinish: function onFinish() {}
+			});
 		}
 		self.lastPlayerDistance = distance;
 	};
 	self.takeDamage = function (damage) {