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

/**** 
* Classes
****/ 
var Enemy = Container.expand(function (type, wave, pathIndex, strengthLevel) {
	var self = Container.call(this);
	self.type = type;
	self.wave = wave;
	self.pathIndex = pathIndex || 1;
	self.strengthLevel = strengthLevel || 1;
	self.currentPath = self.pathIndex === 1 ? enemyPath1 : self.pathIndex === 2 ? enemyPath2 : enemyPath3;
	// Define base stats for each enemy type (reduced by 30% for balance)
	var baseStats = {
		goblin: {
			speed: 2.1,
			health: 28,
			coins: 7,
			flying: false
		},
		crawler: {
			speed: 1.4,
			health: 42,
			coins: 10,
			flying: false
		},
		bandit: {
			speed: 1.75,
			health: 35,
			coins: 12,
			flying: false
		},
		golem: {
			speed: 0.7,
			health: 105,
			coins: 18,
			flying: false
		},
		imp: {
			speed: 1.9,
			health: 49,
			coins: 15,
			flying: false
		},
		knight: {
			speed: 1.05,
			health: 70,
			coins: 20,
			flying: false
		},
		beast: {
			speed: 0.9,
			health: 84,
			coins: 22,
			flying: false
		},
		mage: {
			speed: 1.2,
			health: 56,
			coins: 25,
			flying: false
		},
		reaver: {
			speed: 2.3,
			health: 63,
			coins: 28,
			flying: true
		},
		doom: {
			speed: 0.8,
			health: 140,
			coins: 35,
			flying: false
		}
	};
	var stats = baseStats[type] || baseStats.goblin;
	// Scale stats by strength level
	var strengthMultiplier = 1 + (self.strengthLevel - 1) * 0.4;
	var speedMultiplier = 1 + (self.strengthLevel - 1) * 0.08;
	self.speed = stats.speed * speedMultiplier;
	self.maxHealth = Math.floor(stats.health * strengthMultiplier);
	self.health = self.maxHealth;
	self.pathStep = 0;
	self.coinValue = Math.floor(stats.coins * strengthMultiplier);
	self.flying = stats.flying;
	self.regeneration = type === 'beast' ? 0.5 : 0;
	self.poisonResistant = type === 'doom';
	self.slowResistant = type === 'doom';
	var graphics = self.attachAsset('enemy_' + type, {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.x = self.currentPath[0].x;
	self.y = self.currentPath[0].y;
	self.takeDamage = function (damage) {
		self.health -= damage;
		LK.effects.flashObject(self, 0xFF0000, 200);
		if (self.health <= 0) {
			LK.getSound('enemy_hit').play();
			return true;
		}
		return false;
	};
	self.update = function () {
		if (self.pathStep < self.currentPath.length - 1) {
			var target = self.currentPath[self.pathStep + 1];
			var dx = target.x - self.x;
			var dy = target.y - self.y;
			var distance = Math.sqrt(dx * dx + dy * dy);
			if (distance < 5) {
				self.pathStep++;
				if (self.pathStep >= self.currentPath.length - 1) {
					self.reachedCastle = true;
				}
			} else {
				self.x += dx / distance * self.speed;
				self.y += dy / distance * self.speed;
			}
		}
	};
	return self;
});
var Projectile = Container.expand(function (type, startX, startY, targetX, targetY, damage) {
	var self = Container.call(this);
	self.type = type;
	self.damage = damage;
	self.targetX = targetX;
	self.targetY = targetY;
	self.speed = type === 'arrow' ? 8 : type === 'cannonball' ? 5 : 6;
	var graphics = self.attachAsset('projectile_' + type, {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.x = startX;
	self.y = startY;
	var dx = targetX - startX;
	var dy = targetY - startY;
	var distance = Math.sqrt(dx * dx + dy * dy);
	self.velocityX = dx / distance * self.speed;
	self.velocityY = dy / distance * self.speed;
	self.update = function () {
		self.x += self.velocityX;
		self.y += self.velocityY;
		var distToTarget = Math.sqrt((self.x - self.targetX) * (self.x - self.targetX) + (self.y - self.targetY) * (self.y - self.targetY));
		if (distToTarget < 10) {
			self.hasReachedTarget = true;
		}
	};
	return self;
});
var Tower = Container.expand(function (type) {
	var self = Container.call(this);
	self.type = type;
	self.level = 1;
	self.lastShotTime = 0;
	self.maxLevel = type === 'antiair' || type === 'poison' || type === 'tesla' ? 5 : 10;
	// Initialize tower stats based on type
	if (type === 'infantry') {
		self.damage = 20;
		self.range = 100;
		self.attackSpeed = 600;
		self.cost = 80;
		self.projectileType = 'arrow';
	} else if (type === 'frost') {
		self.damage = 15;
		self.range = 90;
		self.attackSpeed = 800;
		self.cost = 120;
		self.projectileType = 'magic';
		self.slowEffect = true;
	} else if (type === 'antiair') {
		self.damage = 40;
		self.range = 130;
		self.attackSpeed = 1000;
		self.cost = 150;
		self.projectileType = 'magic';
		self.antiAir = true;
	} else if (type === 'poison') {
		self.damage = 10;
		self.range = 80;
		self.attackSpeed = 1200;
		self.cost = 100;
		self.projectileType = 'magic';
		self.poisonEffect = true;
	} else if (type === 'tesla') {
		self.damage = 35;
		self.range = 95;
		self.attackSpeed = 900;
		self.cost = 180;
		self.projectileType = 'magic';
		self.chainLightning = true;
	}
	var graphics = self.attachAsset('tower_' + type, {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.getUpgradeNames = function () {
		if (self.type === 'infantry') {
			return ['Rifleman', 'Marksman', 'Sharpshooter', 'Machine Gunner', 'Grenadier', 'Mortar Operator', 'Tank Commander', 'Bazooka Specialist', 'Rocket Launcher', 'Missile Battery'];
		} else if (self.type === 'frost') {
			return ['Frost Spire', 'Ice Shard Tower', 'Blizzard Bastion', 'Cryo Cannon', 'Glacier Fortress', 'Snowstorm Citadel', 'Avalanche Keep', 'Frozen Maelstrom', 'Arctic Warden', 'Absolute Zero'];
		} else if (self.type === 'antiair') {
			return ['Flak Cannon', 'SAM Launcher', 'Radar Missile Battery', 'Laser Air Defense', 'Plasma Barrier'];
		} else if (self.type === 'poison') {
			return ['Venom Sprayer', 'Toxic Spitter', 'Acid Dart Tower', 'Corrosive Spire', 'Plague Altar'];
		} else if (self.type === 'tesla') {
			return ['Static Coil', 'Dual Coil', 'Arc Emitter', 'Thunderstorm Core', 'Lightning God'];
		}
	};
	self.canShoot = function () {
		return LK.ticks - self.lastShotTime > self.attackSpeed / (1000 / 60);
	};
	self.findTarget = function () {
		var closestEnemy = null;
		var closestDistance = Infinity;
		for (var i = 0; i < enemies.length; i++) {
			var enemy = enemies[i];
			var distance = Math.sqrt((enemy.x - self.x) * (enemy.x - self.x) + (enemy.y - self.y) * (enemy.y - self.y));
			if (distance <= self.range && distance < closestDistance) {
				closestDistance = distance;
				closestEnemy = enemy;
			}
		}
		return closestEnemy;
	};
	self.shoot = function (target) {
		if (!self.canShoot()) return;
		self.lastShotTime = LK.ticks;
		var projectile = new Projectile(self.projectileType, self.x, self.y, target.x, target.y, self.damage);
		projectile.towerType = self.type;
		projectile.slowEffect = self.slowEffect;
		projectile.poisonEffect = self.poisonEffect;
		projectile.chainLightning = self.chainLightning;
		projectiles.push(projectile);
		isoContainer.addChild(projectile);
		LK.getSound('shoot_arrow').play();
	};
	self.getUpgradeCost = function () {
		var baseCosts = [50, 100, 150, 200, 250, 300, 350, 400, 450, 500];
		return baseCosts[self.level - 1] || 500;
	};
	self.upgrade = function () {
		if (self.level < self.maxLevel) {
			self.level++;
			self.damage = Math.floor(self.damage * 1.3);
			self.range = Math.floor(self.range * (1 + (self.level - 1) * 0.1)); // 10% range increase per level
			self.attackSpeed = Math.max(200, Math.floor(self.attackSpeed * 0.95));
			// Visual upgrade indicators
			var tintColors = [0xFFFFFF, 0xFFD700, 0xFF6347, 0xFF4500, 0x8A2BE2, 0x00FF00, 0x00FFFF, 0xFF69B4, 0xFFFF00, 0xFF0000];
			graphics.tint = tintColors[self.level - 1] || 0xFF0000;
			// Show range indicator for upgraded towers
			if (self.level > 1 && !self.rangeIndicator) {
				self.rangeIndicator = LK.getAsset('build_zone', {
					anchorX: 0.5,
					anchorY: 0.5,
					alpha: 0.1,
					scaleX: self.range / 40,
					scaleY: self.range / 40
				});
				self.rangeIndicator.x = self.x;
				self.rangeIndicator.y = self.y;
				self.rangeIndicator.tint = 0x00FF00;
				isoContainer.addChild(self.rangeIndicator);
			} else if (self.rangeIndicator) {
				self.rangeIndicator.scaleX = self.range / 40;
				self.rangeIndicator.scaleY = self.range / 40;
			}
		}
	};
	self.down = function (x, y, obj) {
		selectedTower = self;
		if (upgradeText && upgradeText.destroy) {
			upgradeText.destroy();
		}
		if (self.level < self.maxLevel) {
			var cost = self.getUpgradeCost();
			var names = self.getUpgradeNames();
			var nextName = names[self.level - 1] || 'Max Level';
			upgradeText = new Text2(nextName + ': ' + cost + ' gold', {
				size: 24,
				fill: coins >= cost ? 0x00FF00 : 0xFF0000
			});
			upgradeText.anchor.set(0.5, 1);
			upgradeText.x = self.x;
			upgradeText.y = self.y - 40;
			isoContainer.addChild(upgradeText);
			if (coins >= cost) {
				upgradeText.down = function () {
					coins -= cost;
					coinsText.setText('Gold: ' + coins);
					self.upgrade();
					if (upgradeText && upgradeText.destroy) {
						upgradeText.destroy();
					}
					upgradeText = null;
					selectedTower = null;
				};
			}
		} else {
			upgradeText = new Text2('MAX LEVEL', {
				size: 30,
				fill: 0xFFFFFF
			});
			upgradeText.anchor.set(0.5, 1);
			upgradeText.x = self.x;
			upgradeText.y = self.y - 40;
			isoContainer.addChild(upgradeText);
		}
	};
	self.update = function () {
		var target = self.findTarget();
		if (target) {
			self.shoot(target);
		}
	};
	return self;
});

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

/**** 
* Game Code
****/ 
// Use game container directly for top-down view
var isoContainer = game;
var gameState = 'setup';
var castleType = 'square';
var difficulty = 'easy';
var currentWave = 0;
var maxWaves = 50;
var waveEnemies = [];
var enemies = [];
var towers = [];
var projectiles = [];
var coins = 300;
var castleHealth = 100;
var waveInProgress = false;
var nextWaveTimer = 0;
var selectedTowerType = null;
var selectedTower = null;
var upgradeText = null;
// Enemy path 1: Northern route - direct path from left to castle
var enemyPath1 = [{
	x: 0,
	y: 400
}, {
	x: 200,
	y: 400
}, {
	x: 400,
	y: 450
}, {
	x: 600,
	y: 500
}, {
	x: 800,
	y: 550
}, {
	x: 1000,
	y: 600
}, {
	x: 1200,
	y: 650
}, {
	x: 1400,
	y: 700
}, {
	x: 1600,
	y: 750
}, {
	x: 1800,
	y: 800
}, {
	x: 1900,
	y: 850
}, {
	x: 1950,
	y: 900
}, {
	x: 1950,
	y: 1000
}];
// Enemy path 2: Southern route - curved path from bottom
var enemyPath2 = [{
	x: 0,
	y: 1800
}, {
	x: 300,
	y: 1750
}, {
	x: 600,
	y: 1700
}, {
	x: 900,
	y: 1650
}, {
	x: 1200,
	y: 1600
}, {
	x: 1400,
	y: 1500
}, {
	x: 1600,
	y: 1400
}, {
	x: 1750,
	y: 1250
}, {
	x: 1850,
	y: 1100
}, {
	x: 1950,
	y: 1000
}];
// Enemy path 3: Northwestern route - starts from far corner and merges with path 1
var enemyPath3 = [{
	x: 0,
	y: 0
}, {
	x: 150,
	y: 50
}, {
	x: 300,
	y: 100
}, {
	x: 450,
	y: 150
}, {
	x: 600,
	y: 200
}, {
	x: 750,
	y: 250
}, {
	x: 900,
	y: 300
}, {
	x: 1000,
	y: 350
}, {
	x: 1100,
	y: 400
}, {
	x: 1200,
	y: 450
}, {
	x: 1300,
	y: 500
}, {
	x: 1400,
	y: 550
}, {
	x: 1500,
	y: 600
}, {
	x: 1600,
	y: 650
}, {
	x: 1700,
	y: 700
}, {
	x: 1800,
	y: 750
}, {
	x: 1900,
	y: 800
}, {
	x: 1950,
	y: 850
}, {
	x: 1950,
	y: 900
}, {
	x: 1950,
	y: 1000
}];
var buildZones = [];
var terrainFeatures = [];
function createPath() {
	// Create path 1
	for (var i = 0; i < enemyPath1.length; i++) {
		var pathTile = isoContainer.addChild(LK.getAsset('path_tile', {
			anchorX: 0.5,
			anchorY: 0.5,
			x: enemyPath1[i].x,
			y: enemyPath1[i].y,
			alpha: 0.7
		}));
	}
	// Create path 2 (for waves 3+)
	if (currentWave >= 3) {
		for (var i = 0; i < enemyPath2.length; i++) {
			var pathTile = isoContainer.addChild(LK.getAsset('path_tile', {
				anchorX: 0.5,
				anchorY: 0.5,
				x: enemyPath2[i].x,
				y: enemyPath2[i].y,
				alpha: 0.7
			}));
		}
	}
	// Create path 3 (for waves 6+)
	if (currentWave >= 6) {
		for (var i = 0; i < enemyPath3.length; i++) {
			var pathTile = isoContainer.addChild(LK.getAsset('path_tile', {
				anchorX: 0.5,
				anchorY: 0.5,
				x: enemyPath3[i].x,
				y: enemyPath3[i].y,
				alpha: 0.7
			}));
		}
	}
	// Create build zones around paths
	createBuildZones();
	// Create terrain features
	createTerrain();
}
function createBuildZones() {
	var zones = [
	// Build zones closer to path 1 (northern route)
	{
		x: 120,
		y: 380
	}, {
		x: 120,
		y: 420
	}, {
		x: 280,
		y: 430
	}, {
		x: 280,
		y: 470
	}, {
		x: 480,
		y: 470
	}, {
		x: 480,
		y: 510
	}, {
		x: 680,
		y: 520
	}, {
		x: 680,
		y: 560
	}, {
		x: 880,
		y: 570
	}, {
		x: 880,
		y: 610
	}, {
		x: 1080,
		y: 620
	}, {
		x: 1080,
		y: 660
	}, {
		x: 1280,
		y: 670
	}, {
		x: 1280,
		y: 710
	}, {
		x: 1480,
		y: 720
	}, {
		x: 1480,
		y: 760
	}, {
		x: 1680,
		y: 770
	}, {
		x: 1680,
		y: 810
	},
	// Build zones closer to path 2 (southern route)
	{
		x: 180,
		y: 1730
	}, {
		x: 180,
		y: 1770
	}, {
		x: 380,
		y: 1710
	}, {
		x: 380,
		y: 1750
	}, {
		x: 580,
		y: 1680
	}, {
		x: 580,
		y: 1720
	}, {
		x: 780,
		y: 1630
	}, {
		x: 780,
		y: 1670
	}, {
		x: 1080,
		y: 1580
	}, {
		x: 1080,
		y: 1620
	}, {
		x: 1280,
		y: 1480
	}, {
		x: 1280,
		y: 1520
	}, {
		x: 1480,
		y: 1380
	}, {
		x: 1480,
		y: 1420
	}, {
		x: 1630,
		y: 1320
	}, {
		x: 1630,
		y: 1360
	}, {
		x: 1730,
		y: 1180
	}, {
		x: 1730,
		y: 1220
	},
	// Build zones closer to path 3 (northwestern route)
	{
		x: 80,
		y: 80
	}, {
		x: 200,
		y: 120
	}, {
		x: 350,
		y: 160
	}, {
		x: 500,
		y: 180
	}, {
		x: 650,
		y: 220
	}, {
		x: 800,
		y: 260
	}, {
		x: 950,
		y: 320
	}, {
		x: 1050,
		y: 370
	}, {
		x: 1150,
		y: 420
	}, {
		x: 1250,
		y: 470
	}, {
		x: 1350,
		y: 520
	}, {
		x: 1450,
		y: 570
	}, {
		x: 1550,
		y: 620
	}, {
		x: 1650,
		y: 670
	}, {
		x: 1750,
		y: 720
	},
	// Central strategic positions near castle
	{
		x: 1850,
		y: 950
	}, {
		x: 1800,
		y: 1050
	}, {
		x: 1700,
		y: 1100
	}, {
		x: 1600,
		y: 1050
	}];
	for (var i = 0; i < zones.length; i++) {
		var zone = isoContainer.addChild(LK.getAsset('build_zone', {
			anchorX: 0.5,
			anchorY: 0.5,
			x: zones[i].x,
			y: zones[i].y,
			alpha: 0.3
		}));
		zone.zoneData = {
			x: zones[i].x,
			y: zones[i].y,
			occupied: false,
			originalAlpha: 0.3
		};
		buildZones.push(zone);
	}
}
function updateBuildZoneVisuals() {
	for (var i = 0; i < buildZones.length; i++) {
		var zone = buildZones[i];
		if (zone.zoneData.occupied) {
			// Occupied zones are invisible
			zone.alpha = 0;
		} else if (selectedTowerType) {
			// Available zones are highlighted when a tower is selected
			zone.alpha = 0.6;
			zone.tint = 0x00FF00; // Green highlight for available zones
		} else {
			// Normal state when no tower is selected
			zone.alpha = zone.zoneData.originalAlpha;
			zone.tint = 0xFFFFFF; // Reset tint
		}
	}
}
function createTerrain() {
	// Add rocks
	var rocks = [{
		x: 150,
		y: 300
	}, {
		x: 350,
		y: 450
	}, {
		x: 550,
		y: 550
	}, {
		x: 750,
		y: 650
	}, {
		x: 950,
		y: 750
	}, {
		x: 1150,
		y: 850
	}, {
		x: 1350,
		y: 950
	}, {
		x: 1550,
		y: 1050
	}, {
		x: 250,
		y: 1600
	}, {
		x: 450,
		y: 1500
	}, {
		x: 650,
		y: 1400
	}];
	for (var i = 0; i < rocks.length; i++) {
		var rock = isoContainer.addChild(LK.getAsset('terrain_rock', {
			anchorX: 0.5,
			anchorY: 0.5,
			x: rocks[i].x,
			y: rocks[i].y,
			alpha: 0.8
		}));
		terrainFeatures.push(rock);
	}
	// Add trees
	var trees = [{
		x: 180,
		y: 350
	}, {
		x: 380,
		y: 480
	}, {
		x: 580,
		y: 580
	}, {
		x: 780,
		y: 680
	}, {
		x: 980,
		y: 780
	}, {
		x: 1180,
		y: 880
	}, {
		x: 280,
		y: 1550
	}, {
		x: 480,
		y: 1450
	}];
	for (var i = 0; i < trees.length; i++) {
		var tree = isoContainer.addChild(LK.getAsset('terrain_tree', {
			anchorX: 0.5,
			anchorY: 0.5,
			x: trees[i].x,
			y: trees[i].y,
			alpha: 0.9
		}));
		terrainFeatures.push(tree);
	}
	// Add ruins
	var ruins = [{
		x: 220,
		y: 380
	}, {
		x: 420,
		y: 510
	}, {
		x: 620,
		y: 610
	}, {
		x: 820,
		y: 710
	}, {
		x: 320,
		y: 1580
	}];
	for (var i = 0; i < ruins.length; i++) {
		var ruin = isoContainer.addChild(LK.getAsset('terrain_ruins', {
			anchorX: 0.5,
			anchorY: 0.5,
			x: ruins[i].x,
			y: ruins[i].y,
			alpha: 0.7
		}));
		terrainFeatures.push(ruin);
	}
}
function createCastle() {
	var castle = isoContainer.addChild(LK.getAsset('castle_' + castleType, {
		anchorX: 0.5,
		anchorY: 0.5,
		x: enemyPath1[enemyPath1.length - 1].x,
		y: enemyPath1[enemyPath1.length - 1].y
	}));
}
function createShop() {
	var shopBg = LK.gui.bottom.addChild(LK.getAsset('shop_bg', {
		anchorX: 0.5,
		anchorY: 1,
		alpha: 0.8
	}));
	var infantryBtn = LK.gui.bottom.addChild(LK.getAsset('tower_infantry', {
		anchorX: 0.5,
		anchorY: 1,
		x: -400,
		y: -100
	}));
	var frostBtn = LK.gui.bottom.addChild(LK.getAsset('tower_frost', {
		anchorX: 0.5,
		anchorY: 1,
		x: -200,
		y: -100
	}));
	var antiairBtn = LK.gui.bottom.addChild(LK.getAsset('tower_antiair', {
		anchorX: 0.5,
		anchorY: 1,
		x: 0,
		y: -100
	}));
	var poisonBtn = LK.gui.bottom.addChild(LK.getAsset('tower_poison', {
		anchorX: 0.5,
		anchorY: 1,
		x: 200,
		y: -100
	}));
	var teslaBtn = LK.gui.bottom.addChild(LK.getAsset('tower_tesla', {
		anchorX: 0.5,
		anchorY: 1,
		x: 400,
		y: -100
	}));
	// Add cost labels
	var infantryCost = LK.gui.bottom.addChild(new Text2('80g', {
		size: 20,
		fill: 0xFFFFFF
	}));
	infantryCost.anchor.set(0.5, 1);
	infantryCost.x = -400;
	infantryCost.y = -130;
	var frostCost = LK.gui.bottom.addChild(new Text2('120g', {
		size: 20,
		fill: 0xFFFFFF
	}));
	frostCost.anchor.set(0.5, 1);
	frostCost.x = -200;
	frostCost.y = -130;
	var antiairCost = LK.gui.bottom.addChild(new Text2('150g', {
		size: 20,
		fill: 0xFFFFFF
	}));
	antiairCost.anchor.set(0.5, 1);
	antiairCost.x = 0;
	antiairCost.y = -130;
	var poisonCost = LK.gui.bottom.addChild(new Text2('100g', {
		size: 20,
		fill: 0xFFFFFF
	}));
	poisonCost.anchor.set(0.5, 1);
	poisonCost.x = 200;
	poisonCost.y = -130;
	var teslaCost = LK.gui.bottom.addChild(new Text2('180g', {
		size: 20,
		fill: 0xFFFFFF
	}));
	teslaCost.anchor.set(0.5, 1);
	teslaCost.x = 400;
	teslaCost.y = -130;
	infantryBtn.down = function () {
		if (coins >= 80) {
			selectedTowerType = 'infantry';
			updateBuildZoneVisuals();
		}
	};
	frostBtn.down = function () {
		if (coins >= 120) {
			selectedTowerType = 'frost';
			updateBuildZoneVisuals();
		}
	};
	antiairBtn.down = function () {
		if (coins >= 150) {
			selectedTowerType = 'antiair';
			updateBuildZoneVisuals();
		}
	};
	poisonBtn.down = function () {
		if (coins >= 100) {
			selectedTowerType = 'poison';
			updateBuildZoneVisuals();
		}
	};
	teslaBtn.down = function () {
		if (coins >= 180) {
			selectedTowerType = 'tesla';
			updateBuildZoneVisuals();
		}
	};
}
function createWave() {
	if (currentWave >= maxWaves) {
		LK.showYouWin();
		return;
	}
	currentWave++;
	waveEnemies = [];
	var enemyCount = 3 + Math.floor(currentWave / 2);
	if (enemyCount > 20) enemyCount = 20;
	// Calculate available enemy strength levels based on wave
	var maxStrengthLevel = Math.min(10, Math.floor((currentWave + 1) / 2));
	var minStrengthLevel = Math.max(1, maxStrengthLevel - 2);
	for (var i = 0; i < enemyCount; i++) {
		// Define which enemies can appear based on wave number
		var availableEnemies = [];
		if (currentWave >= 1 && currentWave <= 5) availableEnemies.push('goblin');
		if (currentWave >= 3 && currentWave <= 8) availableEnemies.push('crawler');
		if (currentWave >= 5 && currentWave <= 10) availableEnemies.push('bandit');
		if (currentWave >= 7 && currentWave <= 12) availableEnemies.push('golem');
		if (currentWave >= 9 && currentWave <= 14) availableEnemies.push('imp');
		if (currentWave >= 11 && currentWave <= 18) availableEnemies.push('knight');
		if (currentWave >= 13 && currentWave <= 20) availableEnemies.push('beast');
		if (currentWave >= 15 && currentWave <= 25) availableEnemies.push('mage');
		if (currentWave >= 17) availableEnemies.push('reaver');
		if (currentWave >= 45) availableEnemies.push('doom');
		// Select random enemy from available types
		var enemyType = availableEnemies[Math.floor(Math.random() * availableEnemies.length)];
		// Assign strength level within available range
		var strengthLevel = minStrengthLevel + Math.floor(Math.random() * (maxStrengthLevel - minStrengthLevel + 1));
		var pathChoice = 1;
		if (currentWave >= 6) {
			pathChoice = Math.floor(Math.random() * 3) + 1;
		} else if (currentWave >= 3) {
			pathChoice = Math.floor(Math.random() * 2) + 1;
		}
		waveEnemies.push({
			type: enemyType,
			pathIndex: pathChoice,
			strengthLevel: strengthLevel,
			spawnTime: LK.ticks + i * 90
		});
	}
	waveInProgress = true;
	LK.getSound('wave_start').play();
	createPath(); // Recreate paths with new ones visible
}
var coinsText = new Text2('Gold: 300', {
	size: 60,
	fill: 0xFFD700
});
coinsText.anchor.set(0.5, 0);
LK.gui.top.addChild(coinsText);
coinsText.y = 60;
var waveText = new Text2('Wave: 0/50', {
	size: 40,
	fill: 0xFFFFFF
});
waveText.anchor.set(0.5, 0);
LK.gui.top.addChild(waveText);
var healthText = new Text2('Health: 100', {
	size: 40,
	fill: 0xFF0000
});
healthText.anchor.set(0, 0);
LK.gui.left.addChild(healthText);
createPath();
createCastle();
createShop();
game.down = function (x, y, obj) {
	// Clear any existing upgrade text when clicking elsewhere
	if (upgradeText && upgradeText.destroy && selectedTower && obj && !selectedTower.intersects(obj)) {
		upgradeText.destroy();
		upgradeText = null;
		selectedTower = null;
	}
	// Use screen coordinates directly for top-down view
	var isoPos = {
		x: x,
		y: y
	};
	if (selectedTowerType && gameState === 'playing') {
		// Check if clicking on a valid, unoccupied build zone
		var validBuildZone = null;
		for (var i = 0; i < buildZones.length; i++) {
			if (!buildZones[i].zoneData.occupied) {
				var distance = Math.sqrt((buildZones[i].x - isoPos.x) * (buildZones[i].x - isoPos.x) + (buildZones[i].y - isoPos.y) * (buildZones[i].y - isoPos.y));
				if (distance < 40) {
					validBuildZone = buildZones[i];
					break;
				}
			}
		}
		// Only place tower if clicking on a valid build zone and player has enough coins
		if (validBuildZone) {
			var tower = new Tower(selectedTowerType);
			if (coins >= tower.cost) {
				// Place tower exactly at build zone center
				tower.x = validBuildZone.x;
				tower.y = validBuildZone.y;
				towers.push(tower);
				isoContainer.addChild(tower);
				coins -= tower.cost;
				coinsText.setText('Gold: ' + coins);
				selectedTowerType = null;
				// Mark build zone as occupied
				validBuildZone.zoneData.occupied = true;
				updateBuildZoneVisuals();
			}
		} else {
			// Clear selection if clicking outside build zones
			selectedTowerType = null;
			updateBuildZoneVisuals();
		}
	}
};
if (gameState === 'setup') {
	gameState = 'playing';
	createWave();
}
game.update = function () {
	if (gameState !== 'playing') return;
	if (waveInProgress) {
		for (var i = waveEnemies.length - 1; i >= 0; i--) {
			var enemyData = waveEnemies[i];
			if (LK.ticks >= enemyData.spawnTime) {
				var enemy = new Enemy(enemyData.type, currentWave, enemyData.pathIndex, enemyData.strengthLevel);
				enemies.push(enemy);
				isoContainer.addChild(enemy);
				waveEnemies.splice(i, 1);
			}
		}
		if (waveEnemies.length === 0 && enemies.length === 0) {
			waveInProgress = false;
			nextWaveTimer = LK.ticks + 180;
		}
	}
	if (!waveInProgress && LK.ticks >= nextWaveTimer && enemies.length === 0) {
		createWave();
	}
	for (var i = enemies.length - 1; i >= 0; i--) {
		var enemy = enemies[i];
		if (enemy.reachedCastle) {
			castleHealth -= 15;
			healthText.setText('Health: ' + castleHealth);
			enemy.destroy();
			enemies.splice(i, 1);
			if (castleHealth <= 0) {
				LK.showGameOver();
				return;
			}
		}
	}
	for (var i = projectiles.length - 1; i >= 0; i--) {
		var projectile = projectiles[i];
		if (projectile.hasReachedTarget) {
			if (projectile.type === 'cannonball') {
				for (var j = 0; j < enemies.length; j++) {
					var enemy = enemies[j];
					var distance = Math.sqrt((enemy.x - projectile.x) * (enemy.x - projectile.x) + (enemy.y - projectile.y) * (enemy.y - projectile.y));
					if (distance <= 50) {
						if (enemy.takeDamage(projectile.damage)) {
							coins += enemy.coinValue;
							coinsText.setText('Gold: ' + coins);
							enemy.destroy();
							enemies.splice(j, 1);
							j--;
						}
					}
				}
			} else {
				for (var j = 0; j < enemies.length; j++) {
					var enemy = enemies[j];
					var distance = Math.sqrt((enemy.x - projectile.x) * (enemy.x - projectile.x) + (enemy.y - projectile.y) * (enemy.y - projectile.y));
					if (distance <= 25) {
						if (enemy.takeDamage(projectile.damage)) {
							coins += enemy.coinValue;
							coinsText.setText('Gold: ' + coins);
							enemy.destroy();
							enemies.splice(j, 1);
						}
						break;
					}
				}
			}
			projectile.destroy();
			projectiles.splice(i, 1);
		} else if (projectile.x < -50 || projectile.x > 2098 || projectile.y < -50 || projectile.y > 2782) {
			projectile.destroy();
			projectiles.splice(i, 1);
		}
	}
	waveText.setText('Wave: ' + currentWave + '/' + maxWaves);
};

===================================================================
--- original.js
+++ change.js
@@ -525,153 +525,180 @@
 	createTerrain();
 }
 function createBuildZones() {
 	var zones = [
-	// Build zones along path 1 (northern route)
+	// Build zones closer to path 1 (northern route)
 	{
-		x: 150,
-		y: 300
+		x: 120,
+		y: 380
 	}, {
-		x: 150,
-		y: 500
+		x: 120,
+		y: 420
 	}, {
-		x: 350,
-		y: 350
+		x: 280,
+		y: 430
 	}, {
-		x: 350,
-		y: 550
+		x: 280,
+		y: 470
 	}, {
-		x: 550,
-		y: 400
+		x: 480,
+		y: 470
 	}, {
-		x: 550,
-		y: 600
+		x: 480,
+		y: 510
 	}, {
-		x: 750,
-		y: 450
+		x: 680,
+		y: 520
 	}, {
-		x: 750,
-		y: 650
+		x: 680,
+		y: 560
 	}, {
-		x: 950,
-		y: 500
+		x: 880,
+		y: 570
 	}, {
-		x: 950,
-		y: 700
+		x: 880,
+		y: 610
 	}, {
-		x: 1150,
-		y: 550
+		x: 1080,
+		y: 620
 	}, {
-		x: 1150,
-		y: 750
+		x: 1080,
+		y: 660
 	}, {
-		x: 1350,
-		y: 600
+		x: 1280,
+		y: 670
 	}, {
-		x: 1350,
-		y: 800
+		x: 1280,
+		y: 710
 	}, {
-		x: 1550,
-		y: 650
+		x: 1480,
+		y: 720
 	}, {
-		x: 1550,
-		y: 850
+		x: 1480,
+		y: 760
+	}, {
+		x: 1680,
+		y: 770
+	}, {
+		x: 1680,
+		y: 810
 	},
-	// Build zones along path 2 (southern route)  
+	// Build zones closer to path 2 (southern route)
 	{
-		x: 250,
-		y: 1650
+		x: 180,
+		y: 1730
 	}, {
-		x: 250,
-		y: 1850
+		x: 180,
+		y: 1770
 	}, {
-		x: 450,
-		y: 1600
+		x: 380,
+		y: 1710
 	}, {
-		x: 450,
-		y: 1800
+		x: 380,
+		y: 1750
 	}, {
-		x: 750,
-		y: 1550
+		x: 580,
+		y: 1680
 	}, {
-		x: 750,
-		y: 1750
+		x: 580,
+		y: 1720
 	}, {
-		x: 1050,
-		y: 1500
+		x: 780,
+		y: 1630
 	}, {
-		x: 1050,
-		y: 1700
+		x: 780,
+		y: 1670
 	}, {
-		x: 1350,
-		y: 1400
+		x: 1080,
+		y: 1580
 	}, {
-		x: 1350,
-		y: 1600
+		x: 1080,
+		y: 1620
 	}, {
-		x: 1550,
-		y: 1300
+		x: 1280,
+		y: 1480
 	}, {
-		x: 1550,
-		y: 1500
+		x: 1280,
+		y: 1520
 	}, {
-		x: 1700,
-		y: 1200
+		x: 1480,
+		y: 1380
 	}, {
-		x: 1700,
-		y: 1400
+		x: 1480,
+		y: 1420
+	}, {
+		x: 1630,
+		y: 1320
+	}, {
+		x: 1630,
+		y: 1360
+	}, {
+		x: 1730,
+		y: 1180
+	}, {
+		x: 1730,
+		y: 1220
 	},
-	// Build zones along path 3 (northwestern route)
+	// Build zones closer to path 3 (northwestern route)
 	{
-		x: 100,
-		y: 150
+		x: 80,
+		y: 80
 	}, {
-		x: 250,
-		y: 200
+		x: 200,
+		y: 120
 	}, {
-		x: 400,
-		y: 250
+		x: 350,
+		y: 160
 	}, {
-		x: 550,
-		y: 300
+		x: 500,
+		y: 180
 	}, {
-		x: 700,
-		y: 350
+		x: 650,
+		y: 220
 	}, {
-		x: 850,
-		y: 400
+		x: 800,
+		y: 260
 	}, {
-		x: 1000,
-		y: 450
+		x: 950,
+		y: 320
 	}, {
+		x: 1050,
+		y: 370
+	}, {
 		x: 1150,
-		y: 500
+		y: 420
 	}, {
-		x: 1300,
-		y: 550
+		x: 1250,
+		y: 470
 	}, {
+		x: 1350,
+		y: 520
+	}, {
 		x: 1450,
-		y: 600
+		y: 570
 	}, {
-		x: 1600,
-		y: 650
+		x: 1550,
+		y: 620
 	}, {
+		x: 1650,
+		y: 670
+	}, {
 		x: 1750,
-		y: 700
+		y: 720
 	},
-	// Central strategic positions
+	// Central strategic positions near castle
 	{
-		x: 1750,
-		y: 1000
+		x: 1850,
+		y: 950
 	}, {
-		x: 1750,
+		x: 1800,
+		y: 1050
+	}, {
+		x: 1700,
 		y: 1100
 	}, {
 		x: 1600,
-		y: 1150
-	}, {
-		x: 1450,
-		y: 1150
+		y: 1050
 	}];
 	for (var i = 0; i < zones.length; i++) {
 		var zone = isoContainer.addChild(LK.getAsset('build_zone', {
 			anchorX: 0.5,