/**** 
* 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: Straight horizontal then vertical path
var enemyPath1 = [{
	x: 0,
	y: 200
}, {
	x: 128,
	y: 200
}, {
	x: 256,
	y: 200
}, {
	x: 384,
	y: 200
}, {
	x: 512,
	y: 200
}, {
	x: 640,
	y: 200
}, {
	x: 768,
	y: 200
}, {
	x: 896,
	y: 200
}, {
	x: 1024,
	y: 200
}, {
	x: 1024,
	y: 400
}, {
	x: 1024,
	y: 600
}, {
	x: 896,
	y: 600
}, {
	x: 768,
	y: 600
}, {
	x: 768,
	y: 800
}, {
	x: 768,
	y: 1000
}, {
	x: 768,
	y: 1200
}, {
	x: 768,
	y: 1400
}, {
	x: 768,
	y: 1600
}, {
	x: 768,
	y: 1800
}, {
	x: 896,
	y: 1800
}, {
	x: 1024,
	y: 1800
}, {
	x: 1024,
	y: 2000
}, {
	x: 1024,
	y: 2200
}];
// Enemy path 2: Eastern route - long curved path from right side, more parallel final approach
var enemyPath2 = [{
	x: 2048,
	y: 800
}, {
	x: 1920,
	y: 800
}, {
	x: 1792,
	y: 800
}, {
	x: 1664,
	y: 800
}, {
	x: 1536,
	y: 800
}, {
	x: 1408,
	y: 800
}, {
	x: 1280,
	y: 800
}, {
	x: 1152,
	y: 800
}, {
	x: 1024,
	y: 800
}, {
	x: 1024,
	y: 700
}, {
	x: 1024,
	y: 600
}, {
	x: 1152,
	y: 600
}, {
	x: 1280,
	y: 600
}, {
	x: 1280,
	y: 800
}, {
	x: 1280,
	y: 1000
}, {
	x: 1280,
	y: 1200
}, {
	x: 1280,
	y: 1400
}, {
	x: 1280,
	y: 1600
}, {
	x: 1280,
	y: 1800
}, {
	x: 1152,
	y: 1800
}, {
	x: 1024,
	y: 1800
}, {
	x: 1024,
	y: 2000
}, {
	x: 1024,
	y: 2200
}];
// Enemy path 3: Western route - very long winding path from top-right corner, more parallel final approach
var enemyPath3 = [{
	x: 2048,
	y: 50
}, {
	x: 1920,
	y: 50
}, {
	x: 1792,
	y: 50
}, {
	x: 1664,
	y: 50
}, {
	x: 1536,
	y: 50
}, {
	x: 1408,
	y: 50
}, {
	x: 1280,
	y: 50
}, {
	x: 1280,
	y: 200
}, {
	x: 1280,
	y: 400
}, {
	x: 1280,
	y: 600
}, {
	x: 1280,
	y: 800
}, {
	x: 1280,
	y: 1000
}, {
	x: 1280,
	y: 1200
}, {
	x: 1280,
	y: 1400
}, {
	x: 1280,
	y: 1600
}, {
	x: 1280,
	y: 1800
}, {
	x: 1152,
	y: 1800
}, {
	x: 1024,
	y: 1800
}, {
	x: 1024,
	y: 2000
}, {
	x: 1024,
	y: 2200
}];
var buildZones = [];
var terrainFeatures = [];
function createPath() {
	// Create all paths visible from the start for strategic planning
	// 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 - always visible
	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 - always visible
	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();
}
function createTerrain() {
	// Create lake
	var lake = isoContainer.addChild(LK.getAsset('lake', {
		anchorX: 0.5,
		anchorY: 0.5,
		x: 400,
		y: 500,
		alpha: 0.8
	}));
	// Create waterfall (three parallel lines)
	var waterfall1 = isoContainer.addChild(LK.getAsset('waterfall_line', {
		anchorX: 0.5,
		anchorY: 0.5,
		x: 1550,
		y: 300
	}));
	var waterfall2 = isoContainer.addChild(LK.getAsset('waterfall_line', {
		anchorX: 0.5,
		anchorY: 0.5,
		x: 1560,
		y: 300
	}));
	var waterfall3 = isoContainer.addChild(LK.getAsset('waterfall_line', {
		anchorX: 0.5,
		anchorY: 0.5,
		x: 1570,
		y: 300
	}));
	// Create trees in left empty area (avoiding lake)
	for (var x = 50; x <= 650; x += 100) {
		for (var y = 300; y <= 1700; y += 100) {
			var distanceToLake = Math.sqrt((x - 400) * (x - 400) + (y - 500) * (y - 500));
			if (distanceToLake > 150) {
				// Avoid lake area
				var tree = isoContainer.addChild(LK.getAsset('tree', {
					anchorX: 0.5,
					anchorY: 0.5,
					x: x,
					y: y,
					alpha: 0.7
				}));
			}
		}
	}
	// Create trees in right empty area
	for (var x = 1400; x <= 1900; x += 100) {
		for (var y = 900; y <= 1700; y += 100) {
			var tree = isoContainer.addChild(LK.getAsset('tree', {
				anchorX: 0.5,
				anchorY: 0.5,
				x: x,
				y: y,
				alpha: 0.7
			}));
		}
	}
	// Create ruins
	var ruin1 = isoContainer.addChild(LK.getAsset('ruin', {
		anchorX: 0.5,
		anchorY: 0.5,
		x: 475,
		y: 825,
		alpha: 0.8
	}));
	var ruin2 = isoContainer.addChild(LK.getAsset('ruin', {
		anchorX: 0.5,
		anchorY: 0.5,
		x: 530,
		y: 870,
		alpha: 0.8,
		scaleX: 1.2,
		scaleY: 0.8
	}));
	var ruin3 = isoContainer.addChild(LK.getAsset('ruin', {
		anchorX: 0.5,
		anchorY: 0.5,
		x: 570,
		y: 930,
		alpha: 0.8,
		scaleX: 0.8,
		scaleY: 1.2
	}));
	var ruin4 = isoContainer.addChild(LK.getAsset('ruin', {
		anchorX: 0.5,
		anchorY: 0.5,
		x: 625,
		y: 975,
		alpha: 0.8
	}));
}
function createBuildZones() {
	var zones = [
	// Build zones along path 1 (y=200, left side, both sides)
	{
		x: 0,
		y: 150
	}, {
		x: 0,
		y: 250
	},
	// Near (0, 200)
	{
		x: 100,
		y: 150
	}, {
		x: 100,
		y: 250
	}, {
		x: 200,
		y: 150
	}, {
		x: 200,
		y: 250
	}, {
		x: 300,
		y: 150
	}, {
		x: 300,
		y: 250
	}, {
		x: 400,
		y: 150
	}, {
		x: 400,
		y: 250
	}, {
		x: 500,
		y: 150
	}, {
		x: 500,
		y: 250
	}, {
		x: 600,
		y: 150
	}, {
		x: 600,
		y: 250
	}, {
		x: 700,
		y: 150
	}, {
		x: 700,
		y: 250
	}, {
		x: 800,
		y: 150
	}, {
		x: 800,
		y: 250
	}, {
		x: 900,
		y: 150
	}, {
		x: 900,
		y: 250
	}, {
		x: 1000,
		y: 150
	}, {
		x: 1000,
		y: 250
	},
	// Near (1024, 200)
	// Build zones along path 1 (U-shape, x=1024, y=200-600)
	{
		x: 974,
		y: 200
	}, {
		x: 1074,
		y: 200
	},
	// Corner (1024, 200)
	{
		x: 974,
		y: 300
	}, {
		x: 1074,
		y: 300
	}, {
		x: 974,
		y: 400
	}, {
		x: 1074,
		y: 400
	}, {
		x: 974,
		y: 500
	}, {
		x: 1074,
		y: 500
	}, {
		x: 974,
		y: 600
	}, {
		x: 1074,
		y: 600
	},
	// Corner (1024, 600)
	// Build zones along path 1 (U-shape, x=768, y=600-1800)
	{
		x: 718,
		y: 600
	}, {
		x: 818,
		y: 600
	},
	// Corner (768, 600)
	{
		x: 718,
		y: 700
	}, {
		x: 818,
		y: 700
	}, {
		x: 718,
		y: 800
	}, {
		x: 818,
		y: 800
	}, {
		x: 718,
		y: 900
	}, {
		x: 818,
		y: 900
	}, {
		x: 718,
		y: 1000
	}, {
		x: 818,
		y: 1000
	}, {
		x: 718,
		y: 1100
	}, {
		x: 818,
		y: 1100
	}, {
		x: 718,
		y: 1200
	}, {
		x: 818,
		y: 1200
	}, {
		x: 718,
		y: 1300
	}, {
		x: 818,
		y: 1300
	}, {
		x: 718,
		y: 1400
	}, {
		x: 818,
		y: 1400
	}, {
		x: 718,
		y: 1500
	}, {
		x: 818,
		y: 1500
	}, {
		x: 718,
		y: 1600
	}, {
		x: 818,
		y: 1600
	}, {
		x: 718,
		y: 1700
	}, {
		x: 818,
		y: 1700
	}, {
		x: 718,
		y: 1800
	}, {
		x: 818,
		y: 1800
	},
	// Corner (768, 1800)
	// Build zones along path 2 (y=800, right side, both sides)
	{
		x: 2048,
		y: 750
	}, {
		x: 2048,
		y: 850
	},
	// Near (2048, 800)
	{
		x: 1948,
		y: 750
	}, {
		x: 1948,
		y: 850
	}, {
		x: 1848,
		y: 750
	}, {
		x: 1848,
		y: 850
	}, {
		x: 1748,
		y: 750
	}, {
		x: 1748,
		y: 850
	}, {
		x: 1648,
		y: 750
	}, {
		x: 1648,
		y: 850
	}, {
		x: 1548,
		y: 750
	}, {
		x: 1548,
		y: 850
	}, {
		x: 1448,
		y: 750
	}, {
		x: 1448,
		y: 850
	}, {
		x: 1348,
		y: 750
	}, {
		x: 1348,
		y: 850
	}, {
		x: 1248,
		y: 750
	}, {
		x: 1248,
		y: 850
	}, {
		x: 1148,
		y: 750
	}, {
		x: 1148,
		y: 850
	},
	// Near (1024, 800)
	// Build zones along path 2 (U-shape, x=1024, y=600-800)
	{
		x: 974,
		y: 700
	}, {
		x: 1074,
		y: 700
	}, {
		x: 974,
		y: 800
	}, {
		x: 1074,
		y: 800
	},
	// Corner (1024, 800)
	// Build zones along path 2 (U-shape, x=1280, y=600-1800)
	{
		x: 1230,
		y: 600
	}, {
		x: 1330,
		y: 600
	},
	// Corner (1280, 600)
	{
		x: 1230,
		y: 700
	}, {
		x: 1330,
		y: 700
	}, {
		x: 1230,
		y: 800
	}, {
		x: 1330,
		y: 800
	}, {
		x: 1230,
		y: 900
	}, {
		x: 1330,
		y: 900
	}, {
		x: 1230,
		y: 1000
	}, {
		x: 1330,
		y: 1000
	}, {
		x: 1230,
		y: 1100
	}, {
		x: 1330,
		y: 1100
	}, {
		x: 1230,
		y: 1200
	}, {
		x: 1330,
		y: 1200
	}, {
		x: 1230,
		y: 1300
	}, {
		x: 1330,
		y: 1300
	}, {
		x: 1230,
		y: 1400
	}, {
		x: 1330,
		y: 1400
	}, {
		x: 1230,
		y: 1500
	}, {
		x: 1330,
		y: 1500
	}, {
		x: 1230,
		y: 1600
	}, {
		x: 1330,
		y: 1600
	}, {
		x: 1230,
		y: 1700
	}, {
		x: 1330,
		y: 1700
	}, {
		x: 1230,
		y: 1800
	}, {
		x: 1330,
		y: 1800
	},
	// Corner (1280, 1800)
	// Build zones along path 3 (y=50, right side, both sides)
	{
		x: 2048,
		y: 0
	}, {
		x: 2048,
		y: 100
	},
	// Near (2048, 50)
	{
		x: 1948,
		y: 0
	}, {
		x: 1948,
		y: 100
	}, {
		x: 1848,
		y: 0
	}, {
		x: 1848,
		y: 100
	}, {
		x: 1748,
		y: 0
	}, {
		x: 1748,
		y: 100
	}, {
		x: 1648,
		y: 0
	}, {
		x: 1648,
		y: 100
	}, {
		x: 1548,
		y: 0
	}, {
		x: 1548,
		y: 100
	}, {
		x: 1448,
		y: 0
	}, {
		x: 1448,
		y: 100
	}, {
		x: 1348,
		y: 0
	}, {
		x: 1348,
		y: 100
	},
	// Near (1280, 50)
	// Build zones along path 3 (U-shape, x=1280, y=50-1800)
	{
		x: 1230,
		y: 150
	}, {
		x: 1330,
		y: 150
	}, {
		x: 1230,
		y: 250
	}, {
		x: 1330,
		y: 250
	},
	// Strategic positions at intersection points
	{
		x: 974,
		y: 550
	}, {
		x: 1074,
		y: 550
	},
	// Near (1024, 600)
	{
		x: 974,
		y: 650
	}, {
		x: 1074,
		y: 650
	}, {
		x: 974,
		y: 1750
	}, {
		x: 1074,
		y: 1750
	},
	// Near (1024, 1800)
	{
		x: 974,
		y: 1850
	}, {
		x: 1074,
		y: 1850
	}];
	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 createCastle() {
	var castle = isoContainer.addChild(LK.getAsset('castle_' + castleType, {
		anchorX: 0.5,
		anchorY: 0.5,
		x: 1024,
		y: 2200
	}));
}
function createShop() {
	var shopBg = LK.gui.bottom.addChild(LK.getAsset('shop_bg', {
		anchorX: 0.5,
		anchorY: 1,
		alpha: 1.0
	}));
	shopBg.tint = 0x000000;
	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();
}
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();
createTerrain();
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
@@ -587,8 +587,98 @@
 	}
 	// Create build zones around paths
 	createBuildZones();
 }
+function createTerrain() {
+	// Create lake
+	var lake = isoContainer.addChild(LK.getAsset('lake', {
+		anchorX: 0.5,
+		anchorY: 0.5,
+		x: 400,
+		y: 500,
+		alpha: 0.8
+	}));
+	// Create waterfall (three parallel lines)
+	var waterfall1 = isoContainer.addChild(LK.getAsset('waterfall_line', {
+		anchorX: 0.5,
+		anchorY: 0.5,
+		x: 1550,
+		y: 300
+	}));
+	var waterfall2 = isoContainer.addChild(LK.getAsset('waterfall_line', {
+		anchorX: 0.5,
+		anchorY: 0.5,
+		x: 1560,
+		y: 300
+	}));
+	var waterfall3 = isoContainer.addChild(LK.getAsset('waterfall_line', {
+		anchorX: 0.5,
+		anchorY: 0.5,
+		x: 1570,
+		y: 300
+	}));
+	// Create trees in left empty area (avoiding lake)
+	for (var x = 50; x <= 650; x += 100) {
+		for (var y = 300; y <= 1700; y += 100) {
+			var distanceToLake = Math.sqrt((x - 400) * (x - 400) + (y - 500) * (y - 500));
+			if (distanceToLake > 150) {
+				// Avoid lake area
+				var tree = isoContainer.addChild(LK.getAsset('tree', {
+					anchorX: 0.5,
+					anchorY: 0.5,
+					x: x,
+					y: y,
+					alpha: 0.7
+				}));
+			}
+		}
+	}
+	// Create trees in right empty area
+	for (var x = 1400; x <= 1900; x += 100) {
+		for (var y = 900; y <= 1700; y += 100) {
+			var tree = isoContainer.addChild(LK.getAsset('tree', {
+				anchorX: 0.5,
+				anchorY: 0.5,
+				x: x,
+				y: y,
+				alpha: 0.7
+			}));
+		}
+	}
+	// Create ruins
+	var ruin1 = isoContainer.addChild(LK.getAsset('ruin', {
+		anchorX: 0.5,
+		anchorY: 0.5,
+		x: 475,
+		y: 825,
+		alpha: 0.8
+	}));
+	var ruin2 = isoContainer.addChild(LK.getAsset('ruin', {
+		anchorX: 0.5,
+		anchorY: 0.5,
+		x: 530,
+		y: 870,
+		alpha: 0.8,
+		scaleX: 1.2,
+		scaleY: 0.8
+	}));
+	var ruin3 = isoContainer.addChild(LK.getAsset('ruin', {
+		anchorX: 0.5,
+		anchorY: 0.5,
+		x: 570,
+		y: 930,
+		alpha: 0.8,
+		scaleX: 0.8,
+		scaleY: 1.2
+	}));
+	var ruin4 = isoContainer.addChild(LK.getAsset('ruin', {
+		anchorX: 0.5,
+		anchorY: 0.5,
+		x: 625,
+		y: 975,
+		alpha: 0.8
+	}));
+}
 function createBuildZones() {
 	var zones = [
 	// Build zones along path 1 (y=200, left side, both sides)
 	{
@@ -1249,8 +1339,9 @@
 });
 healthText.anchor.set(0, 0);
 LK.gui.left.addChild(healthText);
 createPath();
+createTerrain();
 createCastle();
 createShop();
 game.down = function (x, y, obj) {
 	// Clear any existing upgrade text when clicking elsewhere