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

/**** 
* Classes
****/ 
var Base = Container.expand(function () {
	var self = Container.call(this);
	var baseGraphics = self.attachAsset('base', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	var rangeIndicator = self.attachAsset('rangeIndicator', {
		anchorX: 0.5,
		anchorY: 0.5,
		alpha: 0.2
	});
	self.health = 100;
	self.maxHealth = 100;
	self.attackPower = 10;
	self.attackSpeed = 60; // frames between attacks
	self.attackRange = 400;
	self.multiAttack = 1;
	self.lastAttack = 0;
	self.updateRangeIndicator = function () {
		var scale = self.attackRange * 2 / 800;
		rangeIndicator.scaleX = scale;
		rangeIndicator.scaleY = scale;
	};
	self.takeDamage = function () {
		self.health--;
		LK.effects.flashObject(self, 0xff0000, 300);
		if (self.health <= 0) {
			LK.showGameOver();
		}
		updateHealthDisplay();
	};
	self.canAttack = function () {
		return LK.ticks - self.lastAttack >= self.attackSpeed;
	};
	self.attack = function () {
		if (!self.canAttack()) return;
		var targets = [];
		for (var i = 0; i < enemies.length && targets.length < self.multiAttack; i++) {
			var enemy = enemies[i];
			var dx = enemy.x - self.x;
			var dy = enemy.y - self.y;
			var distance = Math.sqrt(dx * dx + dy * dy);
			if (distance <= self.attackRange) {
				targets.push(enemy);
			}
		}
		for (var j = 0; j < targets.length; j++) {
			var bullet = new Bullet();
			bullet.x = self.x;
			bullet.y = self.y;
			bullet.target = targets[j];
			bullet.damage = self.attackPower;
			bullets.push(bullet);
			game.addChild(bullet);
		}
		if (targets.length > 0) {
			self.lastAttack = LK.ticks;
			LK.getSound('shoot').play();
		}
	};
	return self;
});
var Boss = Container.expand(function () {
	var self = Container.call(this);
	var enemyGraphics = self.attachAsset('boss', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.health = 200;
	self.maxHealth = 200;
	self.speed = 0.8;
	self.direction = {
		x: 0,
		y: 0
	};
	self.lastX = self.x;
	self.lastY = self.y;
	self.setTarget = function (targetX, targetY) {
		var dx = targetX - self.x;
		var dy = targetY - self.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		if (distance > 0) {
			self.direction.x = dx / distance;
			self.direction.y = dy / distance;
		}
	};
	self.takeDamage = function (damage) {
		self.health -= damage;
		LK.effects.flashObject(self, 0xffffff, 200);
		if (self.health <= 0) {
			LK.getSound('enemyHit').play();
			// Create explosion effect
			tween(self, {
				scaleX: 3,
				scaleY: 3,
				alpha: 0
			}, {
				duration: 500,
				easing: tween.easeOut,
				onFinish: function onFinish() {
					// Boss will be removed from enemies array in game.update
				}
			});
			return true; // Boss died
		}
		return false;
	};
	self.update = function () {
		// If boss is dead (health <= 0), don't move and prepare for removal
		if (self.health <= 0) {
			return true; // Remove dead boss
		}
		self.lastX = self.x;
		self.lastY = self.y;
		// Move toward base
		self.setTarget(base.x, base.y);
		self.x += self.direction.x * self.speed;
		self.y += self.direction.y * self.speed;
		// Check if reached base
		var dx = self.x - base.x;
		var dy = self.y - base.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		if (distance < 100) {
			base.takeDamage();
			base.takeDamage(); // Boss does double damage
			return true; // Boss reached base
		}
		return false;
	};
	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.damage = 10;
	self.update = function () {
		if (!self.target || !self.target.parent) {
			return true; // Remove bullet if target is gone
		}
		// 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 < 20) {
			// Hit target
			var enemyDied = self.target.takeDamage(self.damage);
			if (enemyDied) {
				// Different point rewards for different enemy types
				if (self.target instanceof Boss) {
					points += 100;
				} else if (self.target instanceof EnemyTank) {
					points += 20;
				} else if (self.target instanceof EnemyFast) {
					points += 15;
				} else {
					points += 10;
				}
				updatePointsDisplay();
			}
			LK.getSound('hit').play();
			return true; // Remove bullet
		}
		if (distance > 0) {
			self.x += dx / distance * self.speed;
			self.y += dy / distance * self.speed;
		}
		return false;
	};
	return self;
});
var Enemy = Container.expand(function () {
	var self = Container.call(this);
	var enemyGraphics = self.attachAsset('enemy', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.health = 20;
	self.maxHealth = 20;
	self.speed = 1;
	self.direction = {
		x: 0,
		y: 0
	};
	self.lastX = self.x;
	self.lastY = self.y;
	self.setTarget = function (targetX, targetY) {
		var dx = targetX - self.x;
		var dy = targetY - self.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		if (distance > 0) {
			self.direction.x = dx / distance;
			self.direction.y = dy / distance;
		}
	};
	self.takeDamage = function (damage) {
		self.health -= damage;
		LK.effects.flashObject(self, 0xffffff, 200);
		if (self.health <= 0) {
			LK.getSound('enemyHit').play();
			// Create explosion effect
			tween(self, {
				scaleX: 2,
				scaleY: 2,
				alpha: 0
			}, {
				duration: 300,
				easing: tween.easeOut,
				onFinish: function onFinish() {
					// Enemy will be removed from enemies array in game.update
				}
			});
			return true; // Enemy died
		}
		return false;
	};
	self.update = function () {
		// If enemy is dead (health <= 0), don't move and prepare for removal
		if (self.health <= 0) {
			return true; // Remove dead enemy
		}
		self.lastX = self.x;
		self.lastY = self.y;
		// Move toward base
		self.setTarget(base.x, base.y);
		self.x += self.direction.x * self.speed;
		self.y += self.direction.y * self.speed;
		// Check if reached base
		var dx = self.x - base.x;
		var dy = self.y - base.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		if (distance < 70) {
			base.takeDamage();
			return true; // Enemy reached base
		}
		return false;
	};
	return self;
});
var EnemyFast = Container.expand(function () {
	var self = Container.call(this);
	var enemyGraphics = self.attachAsset('enemyFast', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.health = 5;
	self.maxHealth = 5;
	self.speed = 1.5;
	self.direction = {
		x: 0,
		y: 0
	};
	self.lastX = self.x;
	self.lastY = self.y;
	self.setTarget = function (targetX, targetY) {
		var dx = targetX - self.x;
		var dy = targetY - self.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		if (distance > 0) {
			self.direction.x = dx / distance;
			self.direction.y = dy / distance;
		}
	};
	self.takeDamage = function (damage) {
		self.health -= damage;
		LK.effects.flashObject(self, 0xffffff, 200);
		if (self.health <= 0) {
			LK.getSound('enemyHit').play();
			// Create explosion effect
			tween(self, {
				scaleX: 2,
				scaleY: 2,
				alpha: 0
			}, {
				duration: 300,
				easing: tween.easeOut,
				onFinish: function onFinish() {
					// Enemy will be removed from enemies array in game.update
				}
			});
			return true; // Enemy died
		}
		return false;
	};
	self.update = function () {
		// If enemy is dead (health <= 0), don't move and prepare for removal
		if (self.health <= 0) {
			return true; // Remove dead enemy
		}
		self.lastX = self.x;
		self.lastY = self.y;
		// Move toward base
		self.setTarget(base.x, base.y);
		self.x += self.direction.x * self.speed;
		self.y += self.direction.y * self.speed;
		// Check if reached base
		var dx = self.x - base.x;
		var dy = self.y - base.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		if (distance < 70) {
			base.takeDamage();
			return true; // Enemy reached base
		}
		return false;
	};
	return self;
});
// 3 seconds
var EnemyTank = Container.expand(function () {
	var self = Container.call(this);
	var enemyGraphics = self.attachAsset('enemyTank', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.health = 40;
	self.maxHealth = 40;
	self.speed = 0.5;
	self.direction = {
		x: 0,
		y: 0
	};
	self.lastX = self.x;
	self.lastY = self.y;
	self.setTarget = function (targetX, targetY) {
		var dx = targetX - self.x;
		var dy = targetY - self.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		if (distance > 0) {
			self.direction.x = dx / distance;
			self.direction.y = dy / distance;
		}
	};
	self.takeDamage = function (damage) {
		self.health -= damage;
		LK.effects.flashObject(self, 0xffffff, 200);
		if (self.health <= 0) {
			LK.getSound('enemyHit').play();
			// Create explosion effect
			tween(self, {
				scaleX: 2,
				scaleY: 2,
				alpha: 0
			}, {
				duration: 300,
				easing: tween.easeOut,
				onFinish: function onFinish() {
					// Enemy will be removed from enemies array in game.update
				}
			});
			return true; // Enemy died
		}
		return false;
	};
	self.update = function () {
		// If enemy is dead (health <= 0), don't move and prepare for removal
		if (self.health <= 0) {
			return true; // Remove dead enemy
		}
		self.lastX = self.x;
		self.lastY = self.y;
		// Move toward base
		self.setTarget(base.x, base.y);
		self.x += self.direction.x * self.speed;
		self.y += self.direction.y * self.speed;
		// Check if reached base
		var dx = self.x - base.x;
		var dy = self.y - base.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		if (distance < 70) {
			base.takeDamage();
			return true; // Enemy reached base
		}
		return false;
	};
	return self;
});
var UpgradeButton = Container.expand(function (type, cost, description) {
	var self = Container.call(this);
	var buttonGraphics = self.attachAsset('upgradeButton', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.type = type;
	self.cost = cost;
	self.description = description;
	var buttonText = new Text2(description + '\n' + cost + ' pts', {
		size: 24,
		fill: 0xFFFFFF
	});
	buttonText.anchor.set(0.5, 0.5);
	self.addChild(buttonText);
	self.updateCost = function (newCost) {
		self.cost = newCost;
		buttonText.setText(self.description + '\n' + newCost + ' pts');
	};
	self.down = function (x, y, obj) {
		if (points >= self.cost && !waveInProgress) {
			points -= self.cost;
			updatePointsDisplay();
			switch (self.type) {
				case 'power':
					base.attackPower += 5;
					powerUpgradeCost = Math.floor(powerUpgradeCost * 1.5);
					self.updateCost(powerUpgradeCost);
					break;
				case 'speed':
					base.attackSpeed = Math.max(10, base.attackSpeed - 10);
					speedUpgradeCost = Math.floor(speedUpgradeCost * 1.5);
					self.updateCost(speedUpgradeCost);
					break;
				case 'range':
					base.attackRange += 100;
					base.updateRangeIndicator();
					rangeUpgradeCost = Math.floor(rangeUpgradeCost * 1.5);
					self.updateCost(rangeUpgradeCost);
					break;
				case 'multi':
					base.multiAttack += 1;
					multiUpgradeCost = Math.floor(multiUpgradeCost * 2);
					self.updateCost(multiUpgradeCost);
					break;
			}
			LK.effects.flashObject(self, 0xffffff, 300);
		}
	};
	return self;
});

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

/**** 
* Game Code
****/ 
var base = game.addChild(new Base());
base.x = 2048 / 2;
base.y = 2732 / 2;
base.updateRangeIndicator();
var enemies = [];
var bullets = [];
var points = 0;
var wave = 1;
var waveInProgress = false;
var enemiesSpawned = 0;
var enemiesPerWave = 5;
var spawnTimer = 0;
var waveStartDelay = 0;
// Upgrade costs
var powerUpgradeCost = 50;
var speedUpgradeCost = 30;
var rangeUpgradeCost = 40;
var multiUpgradeCost = 100;
// UI Elements
var healthText = new Text2('Health: 100', {
	size: 48,
	fill: 0xFFFFFF
});
healthText.anchor.set(0, 0);
healthText.x = 50;
healthText.y = 150;
LK.gui.topLeft.addChild(healthText);
var pointsText = new Text2('Points: 0', {
	size: 48,
	fill: 0xFFFFFF
});
pointsText.anchor.set(0.5, 0);
pointsText.x = 0;
pointsText.y = 50;
LK.gui.top.addChild(pointsText);
var waveText = new Text2('Wave: 1', {
	size: 48,
	fill: 0xFFFFFF
});
waveText.anchor.set(1, 0);
waveText.x = -50;
waveText.y = 150;
LK.gui.topRight.addChild(waveText);
var statusText = new Text2('Prepare for Wave 1!', {
	size: 36,
	fill: 0xF39C12
});
statusText.anchor.set(0.5, 0.5);
statusText.x = 0;
statusText.y = 0;
LK.gui.center.addChild(statusText);
// Upgrade buttons
var powerButton = new UpgradeButton('power', powerUpgradeCost, 'Attack Power');
powerButton.x = 2048 / 2 - 220;
powerButton.y = 2732 - 150;
game.addChild(powerButton);
var speedButton = new UpgradeButton('speed', speedUpgradeCost, 'Attack Speed');
speedButton.x = 2048 / 2 - 70;
speedButton.y = 2732 - 150;
game.addChild(speedButton);
var rangeButton = new UpgradeButton('range', rangeUpgradeCost, 'Attack Range');
rangeButton.x = 2048 / 2 + 70;
rangeButton.y = 2732 - 150;
game.addChild(rangeButton);
var multiButton = new UpgradeButton('multi', multiUpgradeCost, 'Multi-Attack');
multiButton.x = 2048 / 2 + 220;
multiButton.y = 2732 - 150;
game.addChild(multiButton);
function updateHealthDisplay() {
	healthText.setText('Health: ' + base.health);
}
function updatePointsDisplay() {
	pointsText.setText('Points: ' + points);
}
function startWave() {
	waveInProgress = true;
	enemiesSpawned = 0;
	// Boss waves have only 1 enemy (the boss)
	if (wave % 10 === 0) {
		enemiesPerWave = 1;
		statusText.setText('BOSS WAVE ' + wave + ' - Prepare for battle!');
	} else {
		enemiesPerWave = 8 + wave * 3;
		statusText.setText('Wave ' + wave + ' - ' + enemiesPerWave + ' enemies incoming!');
	}
	spawnTimer = 0;
	waveText.setText('Wave: ' + wave);
}
function spawnEnemy() {
	var enemy;
	// Boss every 10 waves
	if (wave % 10 === 0 && enemiesSpawned === 0) {
		enemy = new Boss();
		// Scale boss stats with wave
		enemy.health = 200 + (wave / 10 - 1) * 100;
		enemy.maxHealth = enemy.health;
		enemy.speed = 0.8 + wave * 0.1;
	} else {
		// Progressive enemy introduction based on wave
		var enemyType;
		if (wave === 1) {
			// Wave 1: Only basic red enemies
			enemyType = 0;
		} else if (wave <= 5) {
			// Waves 2-5: Basic enemies and tanks
			enemyType = Math.floor(Math.random() * 2);
		} else {
			// Wave 6+: All enemy types
			enemyType = Math.floor(Math.random() * 3);
		}
		switch (enemyType) {
			case 0:
				enemy = new Enemy();
				// Scale enemy stats with wave
				enemy.health = 10 + (wave - 1) * 5;
				enemy.maxHealth = enemy.health;
				enemy.speed = 1 + wave * 0.2;
				break;
			case 1:
				enemy = new EnemyTank();
				// Scale tank stats with wave
				enemy.health = 40 + (wave - 1) * 15;
				enemy.maxHealth = enemy.health;
				enemy.speed = 0.5 + wave * 0.1;
				break;
			case 2:
				enemy = new EnemyFast();
				// Scale fast enemy stats with wave
				enemy.health = 5 + (wave - 1) * 2;
				enemy.maxHealth = enemy.health;
				enemy.speed = 1.5 + wave * 0.2;
				break;
		}
	}
	// Random spawn position at screen edges
	var side = Math.floor(Math.random() * 4);
	switch (side) {
		case 0:
			// Top
			enemy.x = Math.random() * 2048;
			enemy.y = -50;
			break;
		case 1:
			// Right
			enemy.x = 2048 + 50;
			enemy.y = Math.random() * 2732;
			break;
		case 2:
			// Bottom
			enemy.x = Math.random() * 2048;
			enemy.y = 2732 + 50;
			break;
		case 3:
			// Left
			enemy.x = -50;
			enemy.y = Math.random() * 2732;
			break;
	}
	enemies.push(enemy);
	game.addChild(enemy);
	enemiesSpawned++;
}
function endWave() {
	waveInProgress = false;
	wave++;
	waveStartDelay = 300; // 5 seconds delay
	statusText.setText('Wave ' + (wave - 1) + ' Complete! Next wave in 5 seconds...');
	// Bonus points for surviving the wave
	points += wave * 10;
	updatePointsDisplay();
}
game.down = function (x, y, obj) {
	// Manual shooting when tapping the screen
	if (waveInProgress) {
		base.attack();
	}
};
game.update = function () {
	// Handle wave progression
	if (!waveInProgress) {
		if (waveStartDelay > 0) {
			waveStartDelay--;
			if (waveStartDelay === 0) {
				startWave();
			}
		}
	} else {
		// Spawn enemies
		if (enemiesSpawned < enemiesPerWave) {
			spawnTimer++;
			if (spawnTimer >= 30) {
				// Spawn every 0.5 seconds
				spawnEnemy();
				spawnTimer = 0;
			}
		}
		// Check if wave is complete
		if (enemiesSpawned >= enemiesPerWave && enemies.length === 0) {
			endWave();
		}
	}
	// Update enemies
	for (var i = enemies.length - 1; i >= 0; i--) {
		var enemy = enemies[i];
		var shouldRemove = enemy.update();
		if (shouldRemove) {
			enemy.destroy();
			enemies.splice(i, 1);
		}
	}
	// Update bullets
	for (var j = bullets.length - 1; j >= 0; j--) {
		var bullet = bullets[j];
		var shouldRemove = bullet.update();
		if (shouldRemove) {
			bullet.destroy();
			bullets.splice(j, 1);
		}
	}
	// Auto-attack
	if (waveInProgress) {
		base.attack();
	}
};
// Start first wave after delay
waveStartDelay = 180;

===================================================================
--- original.js
+++ change.js
@@ -545,10 +545,20 @@
 		enemy.health = 200 + (wave / 10 - 1) * 100;
 		enemy.maxHealth = enemy.health;
 		enemy.speed = 0.8 + wave * 0.1;
 	} else {
-		// Random enemy type for normal waves
-		var enemyType = Math.floor(Math.random() * 3);
+		// Progressive enemy introduction based on wave
+		var enemyType;
+		if (wave === 1) {
+			// Wave 1: Only basic red enemies
+			enemyType = 0;
+		} else if (wave <= 5) {
+			// Waves 2-5: Basic enemies and tanks
+			enemyType = Math.floor(Math.random() * 2);
+		} else {
+			// Wave 6+: All enemy types
+			enemyType = Math.floor(Math.random() * 3);
+		}
 		switch (enemyType) {
 			case 0:
 				enemy = new Enemy();
 				// Scale enemy stats with wave