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

/**** 
* Classes
****/ 
var Barrier = Container.expand(function () {
	var self = Container.call(this);
	var barrierGraphics = self.attachAsset('tower', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	barrierGraphics.tint = 0x8B4513; // Brown tint for barriers
	self.health = 100; // Very high resistance
	self.maxHealth = 100;
	self.lastIntersecting = {};
	self.update = function () {
		// Check collision with zombies
		for (var i = 0; i < zombies.length; i++) {
			var zombie = zombies[i];
			var zombieId = zombies.indexOf(zombie);
			// Initialize last intersecting state if not exists
			if (self.lastIntersecting[zombieId] === undefined) {
				self.lastIntersecting[zombieId] = false;
			}
			var currentIntersecting = self.intersects(zombie);
			// Check if zombie just started intersecting
			if (!self.lastIntersecting[zombieId] && currentIntersecting) {
				// Damage zombie
				zombie.takeDamage();
				// Take damage to barrier
				self.health -= 5;
				// Update barrier appearance based on health
				var healthPercent = self.health / self.maxHealth;
				if (healthPercent > 0.7) {
					barrierGraphics.tint = 0x8B4513; // Brown
				} else if (healthPercent > 0.4) {
					barrierGraphics.tint = 0xFF8C00; // Orange
				} else {
					barrierGraphics.tint = 0xFF0000; // Red
				}
				// Destroy barrier if health reaches 0
				if (self.health <= 0) {
					self.destroy();
					var index = barriers.indexOf(self);
					if (index > -1) {
						barriers.splice(index, 1);
					}
					return;
				}
			}
			// Update last intersecting state
			self.lastIntersecting[zombieId] = currentIntersecting;
		}
	};
	return self;
});
var Bomb = Container.expand(function () {
	var self = Container.call(this);
	var bombGraphics = self.attachAsset('bomb', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.speed = 4;
	self.target = null;
	self.exploded = false;
	self.update = function () {
		if (self.exploded) return;
		if (!self.target || zombies.indexOf(self.target) === -1) {
			self.explode();
			return;
		}
		// Move toward target
		var dx = self.target.x - self.x;
		var dy = self.target.y - self.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		if (distance < 15) {
			// Hit target area
			self.explode();
		} else {
			self.x += dx / distance * self.speed;
			self.y += dy / distance * self.speed;
		}
	};
	self.explode = function () {
		if (self.exploded) return;
		self.exploded = true;
		// Play explosion sound
		LK.getSound('bombExplode').play();
		// Damage all zombies in explosion radius
		var explosionRadius = 80;
		for (var i = 0; i < zombies.length; i++) {
			var zombie = zombies[i];
			var dx = zombie.x - self.x;
			var dy = zombie.y - self.y;
			var distance = Math.sqrt(dx * dx + dy * dy);
			if (distance <= explosionRadius) {
				zombie.takeDamage();
				zombie.takeDamage(); // Bombs do double damage
			}
		}
		// Create explosion effect
		LK.effects.flashObject(self, 0xff4444, 200);
		// Remove bomb
		self.destroy();
		var index = bombs.indexOf(self);
		if (index > -1) {
			bombs.splice(index, 1);
		}
	};
	return self;
});
var Bomber = Container.expand(function () {
	var self = Container.call(this);
	var bomberGraphics = self.attachAsset('bomber', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	bomberGraphics.tint = 0xff6600; // Orange tint for bombers
	self.range = 180;
	self.shootCooldown = 0;
	self.shootRate = 90; // slower than soldiers (more frames between shots)
	self.speed = 0.6;
	self.patrolTarget = null;
	self.mode = 'patrol';
	self.update = function () {
		// Decrease shoot cooldown
		if (self.shootCooldown > 0) {
			self.shootCooldown--;
		}
		// Find nearest zombie in range
		var nearestZombie = null;
		var nearestDistance = Infinity;
		for (var i = 0; i < zombies.length; i++) {
			var zombie = zombies[i];
			var dx = zombie.x - self.x;
			var dy = zombie.y - self.y;
			var distance = Math.sqrt(dx * dx + dy * dy);
			if (distance <= self.range && distance < nearestDistance) {
				nearestDistance = distance;
				nearestZombie = zombie;
			}
		}
		if (nearestZombie && self.shootCooldown === 0) {
			// Combat mode - launch bomb at zombie
			self.mode = 'combat';
			self.launchBomb(nearestZombie);
			self.shootCooldown = self.shootRate;
		} else {
			// Patrol mode - move around
			self.mode = 'patrol';
			if (!self.patrolTarget || self.reachedTarget()) {
				self.setNewPatrolTarget();
			}
			self.moveTowardTarget();
		}
	};
	self.launchBomb = function (target) {
		var bomb = new Bomb();
		bomb.x = self.x;
		bomb.y = self.y;
		bomb.target = target;
		bombs.push(bomb);
		game.addChild(bomb);
	};
	self.setNewPatrolTarget = function () {
		// Set random patrol target around city center
		var angle = Math.random() * Math.PI * 2;
		var radius = 250 + Math.random() * 350;
		self.patrolTarget = {
			x: cityCenter.x + Math.cos(angle) * radius,
			y: cityCenter.y + Math.sin(angle) * radius
		};
		// Keep patrol target within bounds
		self.patrolTarget.x = Math.max(100, Math.min(1948, self.patrolTarget.x));
		self.patrolTarget.y = Math.max(100, Math.min(2632, self.patrolTarget.y));
	};
	self.moveTowardTarget = function () {
		if (!self.patrolTarget) return;
		var dx = self.patrolTarget.x - self.x;
		var dy = self.patrolTarget.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;
		}
	};
	self.reachedTarget = function () {
		if (!self.patrolTarget) return true;
		var dx = self.patrolTarget.x - self.x;
		var dy = self.patrolTarget.y - self.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		return distance < 20;
	};
	return self;
});
var Bullet = Container.expand(function () {
	var self = Container.call(this);
	var bulletGraphics = self.attachAsset('bullet', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.speed = 8;
	self.target = null;
	self.update = function () {
		if (!self.target || zombies.indexOf(self.target) === -1) {
			self.destroy();
			var index = bullets.indexOf(self);
			if (index > -1) {
				bullets.splice(index, 1);
			}
			return;
		}
		// Move toward target
		var dx = self.target.x - self.x;
		var dy = self.target.y - self.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		if (distance < 10) {
			// Hit target
			self.target.takeDamage();
			self.destroy();
			var index = bullets.indexOf(self);
			if (index > -1) {
				bullets.splice(index, 1);
			}
		} else {
			self.x += dx / distance * self.speed;
			self.y += dy / distance * self.speed;
		}
	};
	return self;
});
var FastBullet = Container.expand(function () {
	var self = Container.call(this);
	var bulletGraphics = self.attachAsset('bullet', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	bulletGraphics.tint = 0xff9900; // Orange tint for fast bullets
	self.speed = 10;
	self.target = null;
	self.damage = 0.5; // Low damage
	self.update = function () {
		if (!self.target || zombies.indexOf(self.target) === -1) {
			self.destroy();
			var index = fastBullets.indexOf(self);
			if (index > -1) {
				fastBullets.splice(index, 1);
			}
			return;
		}
		// Move toward target
		var dx = self.target.x - self.x;
		var dy = self.target.y - self.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		if (distance < 10) {
			// Hit target with reduced damage
			self.target.takeDamage(self.damage);
			self.destroy();
			var index = fastBullets.indexOf(self);
			if (index > -1) {
				fastBullets.splice(index, 1);
			}
		} else {
			self.x += dx / distance * self.speed;
			self.y += dy / distance * self.speed;
		}
	};
	return self;
});
var Gunner = Container.expand(function () {
	var self = Container.call(this);
	var gunnerGraphics = self.attachAsset('gunner', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	gunnerGraphics.tint = 0xffa500; // Orange tint for gunners
	self.range = 100;
	self.shootCooldown = 0;
	self.shootRate = 8; // Very fast shooting (much faster than soldiers)
	self.speed = 1.0;
	self.patrolTarget = null;
	self.mode = 'patrol';
	self.update = function () {
		// Decrease shoot cooldown
		if (self.shootCooldown > 0) {
			self.shootCooldown--;
		}
		// Find nearest zombie in range
		var nearestZombie = null;
		var nearestDistance = Infinity;
		for (var i = 0; i < zombies.length; i++) {
			var zombie = zombies[i];
			var dx = zombie.x - self.x;
			var dy = zombie.y - self.y;
			var distance = Math.sqrt(dx * dx + dy * dy);
			if (distance <= self.range && distance < nearestDistance) {
				nearestDistance = distance;
				nearestZombie = zombie;
			}
		}
		if (nearestZombie && self.shootCooldown === 0) {
			// Combat mode - shoot at zombie
			self.mode = 'combat';
			self.shoot(nearestZombie);
			self.shootCooldown = self.shootRate;
		} else {
			// Patrol mode - move around
			self.mode = 'patrol';
			if (!self.patrolTarget || self.reachedTarget()) {
				self.setNewPatrolTarget();
			}
			self.moveTowardTarget();
		}
	};
	self.shoot = function (target) {
		var bullet = new FastBullet();
		bullet.x = self.x;
		bullet.y = self.y;
		bullet.target = target;
		fastBullets.push(bullet);
		game.addChild(bullet);
		LK.getSound('shoot').play();
	};
	self.setNewPatrolTarget = function () {
		// Set random patrol target around city center
		var angle = Math.random() * Math.PI * 2;
		var radius = 180 + Math.random() * 280;
		self.patrolTarget = {
			x: cityCenter.x + Math.cos(angle) * radius,
			y: cityCenter.y + Math.sin(angle) * radius
		};
		// Keep patrol target within bounds
		self.patrolTarget.x = Math.max(100, Math.min(1948, self.patrolTarget.x));
		self.patrolTarget.y = Math.max(100, Math.min(2632, self.patrolTarget.y));
	};
	self.moveTowardTarget = function () {
		if (!self.patrolTarget) return;
		var dx = self.patrolTarget.x - self.x;
		var dy = self.patrolTarget.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;
		}
	};
	self.reachedTarget = function () {
		if (!self.patrolTarget) return true;
		var dx = self.patrolTarget.x - self.x;
		var dy = self.patrolTarget.y - self.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		return distance < 20;
	};
	return self;
});
var Miner = Container.expand(function () {
	var self = Container.call(this);
	var minerGraphics = self.attachAsset('miner', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	minerGraphics.tint = 0xffd700; // Gold tint for miners
	self.moneyTimer = 0;
	self.moneyRate = 180; // Generate money every 3 seconds (180 frames)
	self.lastIntersecting = {};
	self.update = function () {
		// Check collision with zombies first
		for (var i = 0; i < zombies.length; i++) {
			var zombie = zombies[i];
			var zombieId = zombies.indexOf(zombie);
			// Initialize last intersecting state if not exists
			if (self.lastIntersecting[zombieId] === undefined) {
				self.lastIntersecting[zombieId] = false;
			}
			var currentIntersecting = self.intersects(zombie);
			// Check if zombie just started intersecting
			if (!self.lastIntersecting[zombieId] && currentIntersecting) {
				// Transform miner into zombie
				var newZombie = new Zombie();
				newZombie.x = self.x;
				newZombie.y = self.y;
				zombies.push(newZombie);
				game.addChild(newZombie);
				// Remove miner
				self.destroy();
				var minerIndex = miners.indexOf(self);
				if (minerIndex > -1) {
					miners.splice(minerIndex, 1);
				}
				return;
			}
			// Update last intersecting state
			self.lastIntersecting[zombieId] = currentIntersecting;
		}
		self.moneyTimer++;
		if (self.moneyTimer >= self.moneyRate) {
			// Generate money
			gamePoints += 25;
			updateUI();
			// Visual effect when generating money
			LK.effects.flashObject(self, 0xffd700, 500);
			self.moneyTimer = 0;
		}
	};
	return self;
});
var Soldier = Container.expand(function () {
	var self = Container.call(this);
	var soldierGraphics = self.attachAsset('soldier', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	soldierGraphics.tint = 0x4CAF50; // Green tint for soldiers
	self.range = 120;
	self.shootCooldown = 0;
	self.shootRate = 45; // frames between shots
	self.speed = 0.8;
	self.patrolTarget = null;
	self.mode = 'patrol'; // 'patrol' or 'combat'
	self.update = function () {
		// Decrease shoot cooldown
		if (self.shootCooldown > 0) {
			self.shootCooldown--;
		}
		// Find nearest zombie in range
		var nearestZombie = null;
		var nearestDistance = Infinity;
		for (var i = 0; i < zombies.length; i++) {
			var zombie = zombies[i];
			var dx = zombie.x - self.x;
			var dy = zombie.y - self.y;
			var distance = Math.sqrt(dx * dx + dy * dy);
			if (distance <= self.range && distance < nearestDistance) {
				nearestDistance = distance;
				nearestZombie = zombie;
			}
		}
		if (nearestZombie && self.shootCooldown === 0) {
			// Combat mode - shoot at zombie
			self.mode = 'combat';
			self.shoot(nearestZombie);
			self.shootCooldown = self.shootRate;
		} else {
			// Patrol mode - move around
			self.mode = 'patrol';
			if (!self.patrolTarget || self.reachedTarget()) {
				self.setNewPatrolTarget();
			}
			self.moveTowardTarget();
		}
	};
	self.shoot = function (target) {
		var bullet = new Bullet();
		bullet.x = self.x;
		bullet.y = self.y;
		bullet.target = target;
		bullets.push(bullet);
		game.addChild(bullet);
		LK.getSound('shoot').play();
	};
	self.setNewPatrolTarget = function () {
		// Set random patrol target around city center
		var angle = Math.random() * Math.PI * 2;
		var radius = 200 + Math.random() * 300;
		self.patrolTarget = {
			x: cityCenter.x + Math.cos(angle) * radius,
			y: cityCenter.y + Math.sin(angle) * radius
		};
		// Keep patrol target within bounds
		self.patrolTarget.x = Math.max(100, Math.min(1948, self.patrolTarget.x));
		self.patrolTarget.y = Math.max(100, Math.min(2632, self.patrolTarget.y));
	};
	self.moveTowardTarget = function () {
		if (!self.patrolTarget) return;
		var dx = self.patrolTarget.x - self.x;
		var dy = self.patrolTarget.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;
		}
	};
	self.reachedTarget = function () {
		if (!self.patrolTarget) return true;
		var dx = self.patrolTarget.x - self.x;
		var dy = self.patrolTarget.y - self.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		return distance < 20;
	};
	return self;
});
var TankZombie = Container.expand(function () {
	var self = Container.call(this);
	var zombieGraphics = self.attachAsset('tankZombie', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	zombieGraphics.tint = 0x8B0000; // Dark red tint for tank zombies
	self.speed = 0.6; // Slower than regular zombies
	self.health = 20; // Much higher health
	self.maxHealth = 20;
	self.targetX = cityCenter.x;
	self.targetY = cityCenter.y;
	// Create health bar
	var healthBarBg = self.attachAsset('healthBarBg', {
		anchorX: 0.5,
		anchorY: 0.5,
		x: 0,
		y: -50
	});
	var healthBarFill = self.attachAsset('healthBarFill', {
		anchorX: 0,
		anchorY: 0.5,
		x: -29,
		y: -50
	});
	self.update = function () {
		// Move toward city center
		var dx = self.targetX - self.x;
		var dy = self.targetY - 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;
		}
		// Update visual based on health
		var healthPercent = self.health / self.maxHealth;
		if (healthPercent > 0.7) {
			zombieGraphics.tint = 0x8B0000; // Dark red
		} else if (healthPercent > 0.4) {
			zombieGraphics.tint = 0xFF4500; // Orange red
		} else {
			zombieGraphics.tint = 0xFF0000; // Bright red
		}
		// Update health bar
		healthBarFill.width = 58 * healthPercent;
		if (healthPercent > 0.7) {
			healthBarFill.tint = 0x00ff00; // Green
		} else if (healthPercent > 0.3) {
			healthBarFill.tint = 0xffff00; // Yellow
		} else {
			healthBarFill.tint = 0xff0000; // Red
		}
	};
	self.takeDamage = function (damage) {
		if (damage === undefined) damage = 1; // Default damage is 1
		self.health -= damage;
		if (self.health <= 0) {
			self.die();
		}
	};
	self.die = function () {
		LK.getSound('zombieHit').play();
		gamePoints += 20; // More points for killing tank zombies
		updateUI();
		// Remove from zombies array
		var index = zombies.indexOf(self);
		if (index > -1) {
			zombies.splice(index, 1);
		}
		self.destroy();
	};
	return self;
});
var Tower = Container.expand(function () {
	var self = Container.call(this);
	var towerGraphics = self.attachAsset('tower', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.range = 150;
	self.shootCooldown = 0;
	self.shootRate = 30; // frames between shots
	self.level = 1;
	self.update = function () {
		// Check collision with zombies first
		for (var i = 0; i < zombies.length; i++) {
			var zombie = zombies[i];
			var zombieId = zombies.indexOf(zombie);
			// Initialize last intersecting state if not exists
			if (self.lastIntersecting === undefined) {
				self.lastIntersecting = {};
			}
			if (self.lastIntersecting[zombieId] === undefined) {
				self.lastIntersecting[zombieId] = false;
			}
			var currentIntersecting = self.intersects(zombie);
			// Check if zombie just started intersecting
			if (!self.lastIntersecting[zombieId] && currentIntersecting) {
				// Zombie breaks tower
				self.destroy();
				var index = towers.indexOf(self);
				if (index > -1) {
					towers.splice(index, 1);
				}
				return;
			}
			// Update last intersecting state
			self.lastIntersecting[zombieId] = currentIntersecting;
		}
		if (self.shootCooldown > 0) {
			self.shootCooldown--;
			return;
		}
		// Find nearest zombie in range
		var nearestZombie = null;
		var nearestDistance = Infinity;
		for (var i = 0; i < zombies.length; i++) {
			var zombie = zombies[i];
			var dx = zombie.x - self.x;
			var dy = zombie.y - self.y;
			var distance = Math.sqrt(dx * dx + dy * dy);
			if (distance <= self.range && distance < nearestDistance) {
				nearestDistance = distance;
				nearestZombie = zombie;
			}
		}
		if (nearestZombie) {
			self.shoot(nearestZombie);
			self.shootCooldown = self.shootRate;
		}
	};
	self.shoot = function (target) {
		var bullet = new Bullet();
		bullet.x = self.x;
		bullet.y = self.y;
		bullet.target = target;
		bullets.push(bullet);
		game.addChild(bullet);
		LK.getSound('shoot').play();
	};
	self.upgrade = function () {
		if (gamePoints >= self.getUpgradeCost()) {
			gamePoints -= self.getUpgradeCost();
			self.level++;
			self.range += 20;
			self.shootRate = Math.max(10, self.shootRate - 5);
			towerGraphics.tint = 0x2e7d32; // Green tint for upgraded towers
			updateUI();
		}
	};
	self.getUpgradeCost = function () {
		return self.level * 15;
	};
	return self;
});
var Zombie = Container.expand(function () {
	var self = Container.call(this);
	var zombieGraphics = self.attachAsset('zombie', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.speed = 1;
	self.health = 1;
	self.maxHealth = 1;
	self.targetX = cityCenter.x;
	self.targetY = cityCenter.y;
	// Create health bar
	var healthBarBg = self.attachAsset('healthBarBg', {
		anchorX: 0.5,
		anchorY: 0.5,
		x: 0,
		y: -40
	});
	var healthBarFill = self.attachAsset('healthBarFill', {
		anchorX: 0,
		anchorY: 0.5,
		x: -29,
		y: -40
	});
	self.update = function () {
		// Move toward city center
		var dx = self.targetX - self.x;
		var dy = self.targetY - 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;
		}
		// Update health bar
		var healthPercent = self.health / self.maxHealth;
		healthBarFill.width = 58 * healthPercent;
		if (healthPercent > 0.7) {
			healthBarFill.tint = 0x00ff00; // Green
		} else if (healthPercent > 0.3) {
			healthBarFill.tint = 0xffff00; // Yellow
		} else {
			healthBarFill.tint = 0xff0000; // Red
		}
	};
	self.takeDamage = function (damage) {
		if (damage === undefined) damage = 1; // Default damage is 1
		self.health -= damage;
		if (self.health <= 0) {
			self.die();
		}
	};
	self.die = function () {
		LK.getSound('zombieHit').play();
		gamePoints += 5;
		updateUI();
		// Remove from zombies array
		var index = zombies.indexOf(self);
		if (index > -1) {
			zombies.splice(index, 1);
		}
		self.destroy();
	};
	return self;
});

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

/**** 
* Game Code
****/ 
// Game variables
var towers = [];
var zombies = [];
var bullets = [];
var fastBullets = [];
var barriers = [];
var soldiers = [];
var gunners = [];
var bombers = [];
var bombs = [];
var miners = [];
var gamePoints = 50;
var wave = 1;
var zombiesSpawned = 0;
var zombiesToSpawn = 5;
var spawnTimer = 0;
var waveComplete = true;
var gridSize = 80;
var towerCost = 20;
var barrierCost = 30;
var soldierCost = 40;
var gunnerCost = 35;
var bomberCost = 60;
var minerCost = 35;
// Create city center
var cityCenter = game.addChild(LK.getAsset('cityCenter', {
	anchorX: 0.5,
	anchorY: 0.5,
	x: 1024,
	y: 1366
}));
// Create UI elements
var pointsText = new Text2('Points: 50', {
	size: 60,
	fill: 0xFFFFFF
});
pointsText.anchor.set(0, 0);
LK.gui.topRight.addChild(pointsText);
var moneyText = new Text2('Money: 50', {
	size: 60,
	fill: 0xffd700
});
moneyText.anchor.set(1, 0);
moneyText.x = -20;
LK.gui.topRight.addChild(moneyText);
var waveText = new Text2('Wave: 1', {
	size: 60,
	fill: 0xFFFFFF
});
waveText.anchor.set(0.5, 0);
LK.gui.top.addChild(waveText);
// Create GUI buttons
var towerButton = new Text2('Tower (20)', {
	size: 45,
	fill: 0xFFFFFF
});
towerButton.anchor.set(0, 1);
towerButton.x = 20;
towerButton.y = -20;
LK.gui.bottomLeft.addChild(towerButton);
var barrierButton = new Text2('Barrier (30)', {
	size: 45,
	fill: 0xFFFFFF
});
barrierButton.anchor.set(0, 1);
barrierButton.x = 280;
barrierButton.y = -20;
LK.gui.bottomLeft.addChild(barrierButton);
var soldierButton = new Text2('Soldier (40)', {
	size: 45,
	fill: 0xFFFFFF
});
soldierButton.anchor.set(0, 1);
soldierButton.x = 540;
soldierButton.y = -20;
LK.gui.bottomLeft.addChild(soldierButton);
var gunnerButton = new Text2('Gunner (35)', {
	size: 45,
	fill: 0xFFFFFF
});
gunnerButton.anchor.set(0, 1);
gunnerButton.x = 800;
gunnerButton.y = -20;
LK.gui.bottomLeft.addChild(gunnerButton);
var bomberButton = new Text2('Bomber (60)', {
	size: 45,
	fill: 0xFFFFFF
});
bomberButton.anchor.set(0, 1);
bomberButton.x = 1060;
bomberButton.y = -20;
LK.gui.bottomLeft.addChild(bomberButton);
var minerButton = new Text2('Miner (35)', {
	size: 45,
	fill: 0xFFFFFF
});
minerButton.anchor.set(0, 1);
minerButton.x = 20;
minerButton.y = -80;
LK.gui.bottomLeft.addChild(minerButton);
function updateUI() {
	pointsText.setText('Points: ' + gamePoints);
	moneyText.setText('Money: ' + gamePoints);
	waveText.setText('Wave: ' + wave);
}
function snapToGrid(value) {
	return Math.floor(value / gridSize) * gridSize + gridSize / 2;
}
function canPlaceTower(x, y) {
	// Check if position is too close to city center
	var dx = x - cityCenter.x;
	var dy = y - cityCenter.y;
	var distanceToCenter = Math.sqrt(dx * dx + dy * dy);
	if (distanceToCenter < 150) {
		return false;
	}
	// Check if there's already a tower at this position
	for (var i = 0; i < towers.length; i++) {
		var tower = towers[i];
		if (Math.abs(tower.x - x) < gridSize / 2 && Math.abs(tower.y - y) < gridSize / 2) {
			return false;
		}
	}
	// Check if there's already a barrier at this position
	for (var i = 0; i < barriers.length; i++) {
		var barrier = barriers[i];
		if (Math.abs(barrier.x - x) < gridSize / 2 && Math.abs(barrier.y - y) < gridSize / 2) {
			return false;
		}
	}
	return true;
}
function placeTower(x, y) {
	if (gamePoints >= towerCost && canPlaceTower(x, y)) {
		var tower = new Tower();
		tower.x = x;
		tower.y = y;
		towers.push(tower);
		game.addChild(tower);
		gamePoints -= towerCost;
		updateUI();
	}
}
function placeBarrier(x, y) {
	if (gamePoints >= barrierCost && canPlaceTower(x, y)) {
		var barrier = new Barrier();
		barrier.x = x;
		barrier.y = y;
		barriers.push(barrier);
		game.addChild(barrier);
		gamePoints -= barrierCost;
		updateUI();
	}
}
function placeSoldier(x, y) {
	if (gamePoints >= soldierCost) {
		var soldier = new Soldier();
		soldier.x = x;
		soldier.y = y;
		soldiers.push(soldier);
		game.addChild(soldier);
		gamePoints -= soldierCost;
		updateUI();
	}
}
function placeGunner(x, y) {
	if (gamePoints >= gunnerCost) {
		var gunner = new Gunner();
		gunner.x = x;
		gunner.y = y;
		gunners.push(gunner);
		game.addChild(gunner);
		gamePoints -= gunnerCost;
		updateUI();
	}
}
function placeBomber(x, y) {
	if (gamePoints >= bomberCost) {
		var bomber = new Bomber();
		bomber.x = x;
		bomber.y = y;
		bombers.push(bomber);
		game.addChild(bomber);
		gamePoints -= bomberCost;
		updateUI();
	}
}
function placeMiner(x, y) {
	if (gamePoints >= minerCost) {
		var miner = new Miner();
		miner.x = x;
		miner.y = y;
		miners.push(miner);
		game.addChild(miner);
		gamePoints -= minerCost;
		updateUI();
	}
}
function getTowerAt(x, y) {
	for (var i = 0; i < towers.length; i++) {
		var tower = towers[i];
		var dx = Math.abs(tower.x - x);
		var dy = Math.abs(tower.y - y);
		if (dx < gridSize / 2 && dy < gridSize / 2) {
			return tower;
		}
	}
	return null;
}
function updateButtonColors() {
	// Reset all button colors
	towerButton.tint = selectedMode === 'tower' ? 0x4CAF50 : 0xFFFFFF;
	barrierButton.tint = selectedMode === 'barrier' ? 0x4CAF50 : 0xFFFFFF;
	soldierButton.tint = selectedMode === 'soldier' ? 0x4CAF50 : 0xFFFFFF;
	gunnerButton.tint = selectedMode === 'gunner' ? 0x4CAF50 : 0xFFFFFF;
	bomberButton.tint = selectedMode === 'bomber' ? 0x4CAF50 : 0xFFFFFF;
	minerButton.tint = selectedMode === 'miner' ? 0x4CAF50 : 0xFFFFFF;
}
// Button event handlers
towerButton.down = function () {
	selectedMode = 'tower';
	updateButtonColors();
};
barrierButton.down = function () {
	selectedMode = 'barrier';
	updateButtonColors();
};
soldierButton.down = function () {
	selectedMode = 'soldier';
	updateButtonColors();
};
gunnerButton.down = function () {
	selectedMode = 'gunner';
	updateButtonColors();
};
bomberButton.down = function () {
	selectedMode = 'bomber';
	updateButtonColors();
};
minerButton.down = function () {
	selectedMode = 'miner';
	updateButtonColors();
};
// Initialize button colors
updateButtonColors();
function spawnZombie() {
	var zombie;
	// 20% chance to spawn a tank zombie after wave 3
	if (wave >= 3 && Math.random() < 0.2) {
		zombie = new TankZombie();
	} else {
		zombie = new Zombie();
	}
	// Spawn from random edge
	var edge = Math.floor(Math.random() * 4);
	switch (edge) {
		case 0:
			// Top
			zombie.x = Math.random() * 2048;
			zombie.y = 0;
			break;
		case 1:
			// Right
			zombie.x = 2048;
			zombie.y = Math.random() * 2732;
			break;
		case 2:
			// Bottom
			zombie.x = Math.random() * 2048;
			zombie.y = 2732;
			break;
		case 3:
			// Left
			zombie.x = 0;
			zombie.y = Math.random() * 2732;
			break;
	}
	// Increase speed and health with waves
	if (zombie instanceof TankZombie) {
		zombie.speed = 0.6 + (wave - 1) * 0.1; // Tank zombies scale slower
		zombie.health = 20 + Math.floor((wave - 1) / 2);
		zombie.maxHealth = zombie.health;
	} else {
		zombie.speed = 1 + (wave - 1) * 0.2;
		zombie.health = 1 + Math.floor((wave - 1) / 3);
		zombie.maxHealth = zombie.health;
	}
	zombies.push(zombie);
	game.addChild(zombie);
}
function startNextWave() {
	wave++;
	zombiesToSpawn = 5 + wave * 2;
	zombiesSpawned = 0;
	waveComplete = false;
	spawnTimer = 0;
	updateUI();
}
var holdTimer = 0;
var isHolding = false;
var holdPosition = {
	x: 0,
	y: 0
};
var lastTapTime = 0;
var doubleTapDelay = 300; // milliseconds
var selectedMode = 'tower'; // 'tower', 'barrier', 'soldier', or 'bomber'
game.down = function (x, y, obj) {
	var gridX = snapToGrid(x);
	var gridY = snapToGrid(y);
	var existingTower = getTowerAt(gridX, gridY);
	if (existingTower) {
		// Try to upgrade tower
		existingTower.upgrade();
		return;
	}
	// Place unit based on selected mode
	if (selectedMode === 'tower') {
		placeTower(gridX, gridY);
	} else if (selectedMode === 'barrier') {
		placeBarrier(gridX, gridY);
	} else if (selectedMode === 'soldier') {
		placeSoldier(x, y);
	} else if (selectedMode === 'gunner') {
		placeGunner(x, y);
	} else if (selectedMode === 'bomber') {
		placeBomber(x, y);
	} else if (selectedMode === 'miner') {
		placeMiner(x, y);
	}
};
game.update = function () {
	// Spawn zombies for current wave
	if (!waveComplete) {
		spawnTimer++;
		if (spawnTimer >= 60 && zombiesSpawned < zombiesToSpawn) {
			// Spawn every second
			spawnZombie();
			zombiesSpawned++;
			spawnTimer = 0;
		}
		if (zombiesSpawned >= zombiesToSpawn && zombies.length === 0) {
			waveComplete = true;
			LK.setTimeout(startNextWave, 2000); // Start next wave after 2 seconds
		}
	}
	// Check if zombies reached city center
	for (var i = zombies.length - 1; i >= 0; i--) {
		var zombie = zombies[i];
		var dx = zombie.x - cityCenter.x;
		var dy = zombie.y - cityCenter.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		if (distance < 100) {
			// Game over
			LK.showGameOver();
			return;
		}
	}
	// Update all towers (this enables shooting)
	for (var i = 0; i < towers.length; i++) {
		towers[i].update();
	}
	// Update all barriers (this enables damage dealing)
	for (var i = 0; i < barriers.length; i++) {
		barriers[i].update();
	}
	// Update all soldiers (this enables movement and shooting)
	for (var i = 0; i < soldiers.length; i++) {
		soldiers[i].update();
	}
	// Update all gunners (this enables movement and fast shooting)
	for (var i = 0; i < gunners.length; i++) {
		gunners[i].update();
	}
	// Update all bombers (this enables movement and bomb launching)
	for (var i = 0; i < bombers.length; i++) {
		bombers[i].update();
	}
	// Update all bombs (this enables movement and explosion)
	for (var i = 0; i < bombs.length; i++) {
		bombs[i].update();
	}
	// Update all miners (this enables money generation)
	for (var i = 0; i < miners.length; i++) {
		miners[i].update();
	}
	// Update score
	LK.setScore(gamePoints + (wave - 1) * 100);
};
// Start first wave after 3 seconds
LK.setTimeout(startNextWave, 3000);

===================================================================
--- original.js
+++ change.js
@@ -502,8 +502,21 @@
 	self.health = 20; // Much higher health
 	self.maxHealth = 20;
 	self.targetX = cityCenter.x;
 	self.targetY = cityCenter.y;
+	// Create health bar
+	var healthBarBg = self.attachAsset('healthBarBg', {
+		anchorX: 0.5,
+		anchorY: 0.5,
+		x: 0,
+		y: -50
+	});
+	var healthBarFill = self.attachAsset('healthBarFill', {
+		anchorX: 0,
+		anchorY: 0.5,
+		x: -29,
+		y: -50
+	});
 	self.update = function () {
 		// Move toward city center
 		var dx = self.targetX - self.x;
 		var dy = self.targetY - self.y;
@@ -520,8 +533,17 @@
 			zombieGraphics.tint = 0xFF4500; // Orange red
 		} else {
 			zombieGraphics.tint = 0xFF0000; // Bright red
 		}
+		// Update health bar
+		healthBarFill.width = 58 * healthPercent;
+		if (healthPercent > 0.7) {
+			healthBarFill.tint = 0x00ff00; // Green
+		} else if (healthPercent > 0.3) {
+			healthBarFill.tint = 0xffff00; // Yellow
+		} else {
+			healthBarFill.tint = 0xff0000; // Red
+		}
 	};
 	self.takeDamage = function (damage) {
 		if (damage === undefined) damage = 1; // Default damage is 1
 		self.health -= damage;
@@ -631,10 +653,24 @@
 		anchorY: 0.5
 	});
 	self.speed = 1;
 	self.health = 1;
+	self.maxHealth = 1;
 	self.targetX = cityCenter.x;
 	self.targetY = cityCenter.y;
+	// Create health bar
+	var healthBarBg = self.attachAsset('healthBarBg', {
+		anchorX: 0.5,
+		anchorY: 0.5,
+		x: 0,
+		y: -40
+	});
+	var healthBarFill = self.attachAsset('healthBarFill', {
+		anchorX: 0,
+		anchorY: 0.5,
+		x: -29,
+		y: -40
+	});
 	self.update = function () {
 		// Move toward city center
 		var dx = self.targetX - self.x;
 		var dy = self.targetY - self.y;
@@ -642,8 +678,18 @@
 		if (distance > 5) {
 			self.x += dx / distance * self.speed;
 			self.y += dy / distance * self.speed;
 		}
+		// Update health bar
+		var healthPercent = self.health / self.maxHealth;
+		healthBarFill.width = 58 * healthPercent;
+		if (healthPercent > 0.7) {
+			healthBarFill.tint = 0x00ff00; // Green
+		} else if (healthPercent > 0.3) {
+			healthBarFill.tint = 0xffff00; // Yellow
+		} else {
+			healthBarFill.tint = 0xff0000; // Red
+		}
 	};
 	self.takeDamage = function (damage) {
 		if (damage === undefined) damage = 1; // Default damage is 1
 		self.health -= damage;
@@ -959,8 +1005,9 @@
 		zombie.maxHealth = zombie.health;
 	} else {
 		zombie.speed = 1 + (wave - 1) * 0.2;
 		zombie.health = 1 + Math.floor((wave - 1) / 3);
+		zombie.maxHealth = zombie.health;
 	}
 	zombies.push(zombie);
 	game.addChild(zombie);
 }