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

/**** 
* Classes
****/ 
var Bullet = Container.expand(function () {
	var self = Container.call(this);
	var bulletGraphics = self.attachAsset('bullet', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.speed = 15;
	self.damage = 25;
	self.targetX = 0;
	self.targetY = 0;
	self.directionX = 0;
	self.directionY = 0;
	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.directionX = dx / distance;
			self.directionY = dy / distance;
		}
	};
	self.update = function () {
		self.x += self.directionX * self.speed;
		self.y += self.directionY * self.speed;
	};
	return self;
});
var Player = Container.expand(function () {
	var self = Container.call(this);
	var playerGraphics = self.attachAsset('player', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.health = 100;
	self.maxHealth = 100;
	self.ammo = 50;
	self.maxAmmo = 100;
	self.shootCooldown = 0;
	self.shootRate = 15; // shoots every 15 ticks
	self.rapidFireBonus = 0;
	self.takeDamage = function (damage) {
		self.health -= damage;
		if (self.health <= 0) {
			self.health = 0;
			return true; // player died
		}
		return false;
	};
	self.addHealth = function (amount) {
		self.health = Math.min(self.health + amount, self.maxHealth);
	};
	self.addAmmo = function (amount) {
		self.ammo = Math.min(self.ammo + amount, self.maxAmmo);
	};
	self.update = function () {
		if (self.shootCooldown > 0) {
			self.shootCooldown--;
		}
		if (self.rapidFireBonus > 0) {
			self.rapidFireBonus--;
		}
	};
	return self;
});
var PowerUp = Container.expand(function () {
	var self = Container.call(this);
	self.type = 'health';
	self.lifetime = 600; // 10 seconds at 60fps
	self.update = function () {
		self.lifetime--;
		if (self.lifetime <= 0) {
			return true; // should be removed
		}
		return false;
	};
	return self;
});
var RapidFire = PowerUp.expand(function () {
	var self = PowerUp.call(this);
	var packGraphics = self.attachAsset('rapidFire', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.type = 'rapidfire';
	self.value = 300; // 5 seconds of rapid fire
	return self;
});
var HealthPack = PowerUp.expand(function () {
	var self = PowerUp.call(this);
	var packGraphics = self.attachAsset('healthPack', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.type = 'health';
	self.value = 30;
	return self;
});
var AmmoPack = PowerUp.expand(function () {
	var self = PowerUp.call(this);
	var packGraphics = self.attachAsset('ammoPack', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.type = 'ammo';
	self.value = 25;
	return self;
});
var PowerUpManager = Container.expand(function () {
	var self = Container.call(this);
	// Drop table configuration - weights determine relative probability
	self.dropTables = {
		zombie: [{
			type: 'ammo',
			weight: 50,
			"class": AmmoPack
		}, {
			type: 'health',
			weight: 10,
			"class": HealthPack
		}, {
			type: 'rapidfire',
			weight: 5,
			"class": RapidFire
		}, {
			type: 'nothing',
			weight: 35,
			"class": null
		}],
		wave: [{
			type: 'ammo',
			weight: 30,
			"class": AmmoPack
		}, {
			type: 'health',
			weight: 20,
			"class": HealthPack
		}, {
			type: 'rapidfire',
			weight: 15,
			"class": RapidFire
		}, {
			type: 'nothing',
			weight: 35,
			"class": null
		}]
	};
	self.getWeightedDrop = function (dropTable) {
		var totalWeight = 0;
		for (var i = 0; i < dropTable.length; i++) {
			totalWeight += dropTable[i].weight;
		}
		var random = Math.random() * totalWeight;
		var currentWeight = 0;
		for (var i = 0; i < dropTable.length; i++) {
			currentWeight += dropTable[i].weight;
			if (random <= currentWeight) {
				return dropTable[i];
			}
		}
		return dropTable[dropTable.length - 1]; // fallback
	};
	self.spawnDrop = function (x, y, tableType) {
		var dropConfig = self.getWeightedDrop(self.dropTables[tableType || 'zombie']);
		if (dropConfig["class"]) {
			var powerUp = new dropConfig["class"]();
			powerUp.x = x;
			powerUp.y = y;
			powerUps.push(powerUp);
			game.addChild(powerUp);
			return powerUp;
		}
		return null; // no drop
	};
	// Modify drop rates dynamically based on game state
	self.adjustDropRates = function () {
		var survivalTime = gameTime / 3600; // minutes survived
		var difficultyMultiplier = 1 + survivalTime * 0.1;
		// Increase health drops as game gets harder
		if (player.health < 30) {
			self.dropTables.zombie[1].weight = 20; // increase health drop chance
		} else {
			self.dropTables.zombie[1].weight = 10; // normal health drop chance
		}
		// Increase ammo drops if low on ammo
		if (player.ammo < 10) {
			self.dropTables.zombie[0].weight = 70; // increase ammo drop chance
		} else {
			self.dropTables.zombie[0].weight = 50; // normal ammo drop chance
		}
	};
	return self;
});
var Zombie = Container.expand(function () {
	var self = Container.call(this);
	self.health = 50;
	self.maxHealth = 50;
	self.speed = 2;
	self.damage = 20;
	self.scoreValue = 10;
	self.type = 'walker';
	self.takeDamage = function (damage) {
		self.health -= damage;
		return self.health <= 0;
	};
	self.update = function () {
		// Move toward player
		var dx = player.x - self.x;
		var dy = player.y - self.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		if (distance > 0) {
			self.x += dx / distance * self.speed;
			self.y += dy / distance * self.speed;
		}
	};
	return self;
});
var ZombieWalker = Zombie.expand(function () {
	var self = Zombie.call(this);
	var zombieGraphics = self.attachAsset('zombieWalker', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.health = 75;
	self.maxHealth = 75;
	self.speed = 2;
	self.damage = 20;
	self.scoreValue = 10;
	self.type = 'walker';
	return self;
});
var ZombieRunner = Zombie.expand(function () {
	var self = Zombie.call(this);
	var zombieGraphics = self.attachAsset('zombieRunner', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.health = 30;
	self.maxHealth = 30;
	self.speed = 4;
	self.damage = 15;
	self.scoreValue = 15;
	self.type = 'runner';
	return self;
});
var ZombieBrute = Zombie.expand(function () {
	var self = Zombie.call(this);
	var zombieGraphics = self.attachAsset('zombieBrute', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.health = 200;
	self.maxHealth = 200;
	self.speed = 1;
	self.damage = 35;
	self.scoreValue = 25;
	self.type = 'brute';
	return self;
});

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

/**** 
* Game Code
****/ 
// Game variables
var player;
var bullets = [];
var zombies = [];
var powerUps = [];
var powerUpManager;
var waveNumber = 1;
var zombiesKilled = 0;
var gameTime = 0;
var spawnTimer = 0;
var powerUpTimer = 0;
var dragNode = null;
var isShootingEnabled = true; // Toggle for automatic shooting
var difficultyLevel = 1;
var lastDifficultyIncrease = 0;
// UI Elements
var scoreText = new Text2('Score: 0', {
	size: 40,
	fill: 0xFFFFFF
});
scoreText.anchor.set(0, 0);
scoreText.x = 120;
scoreText.y = 20;
LK.gui.topLeft.addChild(scoreText);
var healthText = new Text2('Health: 100', {
	size: 40,
	fill: 0xFF0000
});
healthText.anchor.set(0.5, 0);
LK.gui.top.addChild(healthText);
var ammoText = new Text2('Ammo: 50', {
	size: 40,
	fill: 0xFFFF00
});
ammoText.anchor.set(1, 0);
ammoText.x = -20;
ammoText.y = 20;
LK.gui.topRight.addChild(ammoText);
var waveText = new Text2('Wave: 1', {
	size: 40,
	fill: 0x00FF00
});
waveText.anchor.set(0.5, 0);
waveText.y = 80;
LK.gui.top.addChild(waveText);
var difficultyText = new Text2('Difficulty: 1', {
	size: 35,
	fill: 0xffaa00
});
difficultyText.anchor.set(0.5, 0);
difficultyText.y = 120;
LK.gui.top.addChild(difficultyText);
// Initialize player
player = game.addChild(new Player());
player.x = 1024;
player.y = 1366;
// Initialize power-up manager
powerUpManager = new PowerUpManager();
// Helper functions
function updateUI() {
	scoreText.setText('Score: ' + LK.getScore());
	healthText.setText('Health: ' + player.health);
	ammoText.setText('Ammo: ' + player.ammo);
	waveText.setText('Wave: ' + waveNumber);
	difficultyText.setText('Difficulty: ' + difficultyLevel);
}
function getRandomSpawnPosition() {
	var side = Math.floor(Math.random() * 4);
	var x, y;
	switch (side) {
		case 0:
			// top
			x = Math.random() * 2048;
			y = -50;
			break;
		case 1:
			// right
			x = 2098;
			y = Math.random() * 2732;
			break;
		case 2:
			// bottom
			x = Math.random() * 2048;
			y = 2782;
			break;
		case 3:
			// left
			x = -50;
			y = Math.random() * 2732;
			break;
	}
	return {
		x: x,
		y: y
	};
}
function getDifficultyMultiplier() {
	var timeSurvived = gameTime / 3600; // minutes survived
	return 1 + timeSurvived * 0.2 + (difficultyLevel - 1) * 0.3;
}
function spawnZombie() {
	var pos = getRandomSpawnPosition();
	var zombie;
	var rand = Math.random();
	// Difficulty affects zombie type distribution
	var difficultyMod = getDifficultyMultiplier();
	var walkerChance = Math.max(0.4, 0.6 - difficultyLevel * 0.05);
	var runnerChance = walkerChance + Math.min(0.4, 0.25 + difficultyLevel * 0.03);
	if (rand < walkerChance) {
		zombie = new ZombieWalker();
	} else if (rand < runnerChance) {
		zombie = new ZombieRunner();
	} else {
		zombie = new ZombieBrute();
	}
	// Scale zombie stats based on difficulty
	zombie.health = Math.floor(zombie.health * difficultyMod);
	zombie.maxHealth = zombie.health;
	zombie.damage = Math.floor(zombie.damage * difficultyMod);
	zombie.speed = zombie.speed * Math.min(2.0, 1 + (difficultyLevel - 1) * 0.1);
	zombie.x = pos.x;
	zombie.y = pos.y;
	zombies.push(zombie);
	game.addChild(zombie);
}
function spawnPowerUp() {
	var x = Math.random() * 1800 + 124; // Keep away from edges
	var y = Math.random() * 2400 + 166;
	var powerUp;
	var rand = Math.random();
	if (rand < 0.4) {
		powerUp = new HealthPack();
	} else if (rand < 0.7) {
		powerUp = new AmmoPack();
	} else {
		powerUp = new RapidFire();
	}
	powerUp.x = x;
	powerUp.y = y;
	powerUps.push(powerUp);
	game.addChild(powerUp);
}
function findNearestZombie() {
	var nearestZombie = null;
	var minDistance = Infinity;
	for (var i = 0; i < zombies.length; i++) {
		var zombie = zombies[i];
		var dx = zombie.x - player.x;
		var dy = zombie.y - player.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		if (distance < minDistance) {
			minDistance = distance;
			nearestZombie = zombie;
		}
	}
	return nearestZombie;
}
function shootAtZombie() {
	if (player.ammo <= 0 || player.shootCooldown > 0) {
		return;
	}
	var target = findNearestZombie();
	if (!target) {
		return;
	}
	var bullet = new Bullet();
	bullet.x = player.x;
	bullet.y = player.y;
	bullet.setTarget(target.x, target.y);
	bullets.push(bullet);
	game.addChild(bullet);
	player.ammo--;
	player.shootCooldown = player.rapidFireBonus > 0 ? 5 : player.shootRate;
	LK.getSound('shoot').play();
}
// Event handlers
game.down = function (x, y, obj) {
	// Check if this is a right-click (button 2) or secondary touch
	if (obj.event && obj.event.button === 2) {
		// Toggle shooting on right-click
		isShootingEnabled = !isShootingEnabled;
		// Visual feedback - flash player briefly
		if (isShootingEnabled) {
			LK.effects.flashObject(player, 0x00ff00, 300); // Green flash when enabled
		} else {
			LK.effects.flashObject(player, 0xff0000, 300); // Red flash when disabled
		}
		return;
	}
	// Normal left-click behavior for movement
	dragNode = player;
	player.x = x;
	player.y = y;
};
game.move = function (x, y, obj) {
	if (dragNode) {
		dragNode.x = x;
		dragNode.y = y;
	}
};
game.up = function (x, y, obj) {
	dragNode = null;
};
// Main game loop
game.update = function () {
	gameTime++;
	// Increase difficulty every 2 minutes
	if (gameTime - lastDifficultyIncrease >= 7200) {
		// 2 minutes at 60fps
		difficultyLevel++;
		lastDifficultyIncrease = gameTime;
		// Visual feedback for difficulty increase
		LK.effects.flashScreen(0xffaa00, 1000);
	}
	// Update spawn rate based on wave and difficulty
	var difficultyMod = getDifficultyMultiplier();
	var baseSpawnRate = Math.max(90 - waveNumber * 8, 20);
	var adjustedSpawnRate = Math.max(15, Math.floor(baseSpawnRate / difficultyMod));
	if (gameTime % adjustedSpawnRate === 0) {
		spawnZombie();
	}
	// Spawn additional zombies in later difficulty levels
	if (difficultyLevel >= 3 && gameTime % (adjustedSpawnRate * 2) === 0) {
		spawnZombie();
	}
	if (difficultyLevel >= 5 && gameTime % (adjustedSpawnRate * 3) === 0) {
		spawnZombie();
	}
	// Adjust drop rates based on game state
	powerUpManager.adjustDropRates();
	// Spawn wave-based power-ups occasionally
	powerUpTimer++;
	if (powerUpTimer >= 2400) {
		// Every 40 seconds, spawn from wave table
		var centerX = 1024 + (Math.random() - 0.5) * 800;
		var centerY = 1366 + (Math.random() - 0.5) * 800;
		powerUpManager.spawnDrop(centerX, centerY, 'wave');
		powerUpTimer = 0;
	}
	// Try to shoot (only if shooting is enabled)
	if (isShootingEnabled) {
		shootAtZombie();
	}
	// Update bullets
	for (var i = bullets.length - 1; i >= 0; i--) {
		var bullet = bullets[i];
		// Check if bullet is off screen
		if (bullet.x < -50 || bullet.x > 2098 || bullet.y < -50 || bullet.y > 2782) {
			bullet.destroy();
			bullets.splice(i, 1);
			continue;
		}
		// Check bullet-zombie collisions
		var hitZombie = false;
		for (var j = zombies.length - 1; j >= 0; j--) {
			var zombie = zombies[j];
			if (bullet.intersects(zombie)) {
				if (zombie.takeDamage(bullet.damage)) {
					// Zombie is dead
					LK.setScore(LK.getScore() + zombie.scoreValue);
					zombiesKilled++;
					// Use PowerUpManager for dynamic drops
					powerUpManager.spawnDrop(zombie.x, zombie.y, 'zombie');
					zombie.destroy();
					zombies.splice(j, 1);
					LK.getSound('zombieHit').play();
					// Check for wave progression
					if (zombiesKilled >= waveNumber * 10) {
						waveNumber++;
						zombiesKilled = 0;
					}
				}
				bullet.destroy();
				bullets.splice(i, 1);
				hitZombie = true;
				break;
			}
		}
		if (hitZombie) continue;
	}
	// Update zombies and check player collision
	for (var i = zombies.length - 1; i >= 0; i--) {
		var zombie = zombies[i];
		if (zombie.intersects(player)) {
			if (player.takeDamage(zombie.damage)) {
				// Player died
				LK.showGameOver();
				return;
			}
			LK.getSound('damage').play();
			LK.effects.flashScreen(0xff0000, 500);
			zombie.destroy();
			zombies.splice(i, 1);
		}
	}
	// Update power-ups and check collection
	for (var i = powerUps.length - 1; i >= 0; i--) {
		var powerUp = powerUps[i];
		if (powerUp.update()) {
			// Power-up expired
			powerUp.destroy();
			powerUps.splice(i, 1);
			continue;
		}
		if (powerUp.intersects(player)) {
			LK.getSound('powerup').play();
			switch (powerUp.type) {
				case 'health':
					player.addHealth(powerUp.value);
					break;
				case 'ammo':
					player.addAmmo(powerUp.value);
					break;
				case 'rapidfire':
					player.rapidFireBonus = powerUp.value;
					break;
			}
			powerUp.destroy();
			powerUps.splice(i, 1);
		}
	}
	// Update UI
	updateUI();
	// Check win condition (survive for 10 minutes)
	if (gameTime >= 36000) {
		// 10 minutes at 60fps
		LK.showYouWin();
	}
};

===================================================================
--- original.js
+++ change.js
@@ -287,8 +287,10 @@
 var spawnTimer = 0;
 var powerUpTimer = 0;
 var dragNode = null;
 var isShootingEnabled = true; // Toggle for automatic shooting
+var difficultyLevel = 1;
+var lastDifficultyIncrease = 0;
 // UI Elements
 var scoreText = new Text2('Score: 0', {
 	size: 40,
 	fill: 0xFFFFFF
@@ -317,8 +319,15 @@
 });
 waveText.anchor.set(0.5, 0);
 waveText.y = 80;
 LK.gui.top.addChild(waveText);
+var difficultyText = new Text2('Difficulty: 1', {
+	size: 35,
+	fill: 0xffaa00
+});
+difficultyText.anchor.set(0.5, 0);
+difficultyText.y = 120;
+LK.gui.top.addChild(difficultyText);
 // Initialize player
 player = game.addChild(new Player());
 player.x = 1024;
 player.y = 1366;
@@ -329,8 +338,9 @@
 	scoreText.setText('Score: ' + LK.getScore());
 	healthText.setText('Health: ' + player.health);
 	ammoText.setText('Ammo: ' + player.ammo);
 	waveText.setText('Wave: ' + waveNumber);
+	difficultyText.setText('Difficulty: ' + difficultyLevel);
 }
 function getRandomSpawnPosition() {
 	var side = Math.floor(Math.random() * 4);
 	var x, y;
@@ -360,19 +370,32 @@
 		x: x,
 		y: y
 	};
 }
+function getDifficultyMultiplier() {
+	var timeSurvived = gameTime / 3600; // minutes survived
+	return 1 + timeSurvived * 0.2 + (difficultyLevel - 1) * 0.3;
+}
 function spawnZombie() {
 	var pos = getRandomSpawnPosition();
 	var zombie;
 	var rand = Math.random();
-	if (rand < 0.6) {
+	// Difficulty affects zombie type distribution
+	var difficultyMod = getDifficultyMultiplier();
+	var walkerChance = Math.max(0.4, 0.6 - difficultyLevel * 0.05);
+	var runnerChance = walkerChance + Math.min(0.4, 0.25 + difficultyLevel * 0.03);
+	if (rand < walkerChance) {
 		zombie = new ZombieWalker();
-	} else if (rand < 0.85) {
+	} else if (rand < runnerChance) {
 		zombie = new ZombieRunner();
 	} else {
 		zombie = new ZombieBrute();
 	}
+	// Scale zombie stats based on difficulty
+	zombie.health = Math.floor(zombie.health * difficultyMod);
+	zombie.maxHealth = zombie.health;
+	zombie.damage = Math.floor(zombie.damage * difficultyMod);
+	zombie.speed = zombie.speed * Math.min(2.0, 1 + (difficultyLevel - 1) * 0.1);
 	zombie.x = pos.x;
 	zombie.y = pos.y;
 	zombies.push(zombie);
 	game.addChild(zombie);
@@ -457,13 +480,30 @@
 };
 // Main game loop
 game.update = function () {
 	gameTime++;
-	// Update spawn rate based on wave
-	var baseSpawnRate = Math.max(120 - waveNumber * 10, 30);
-	if (gameTime % baseSpawnRate === 0) {
+	// Increase difficulty every 2 minutes
+	if (gameTime - lastDifficultyIncrease >= 7200) {
+		// 2 minutes at 60fps
+		difficultyLevel++;
+		lastDifficultyIncrease = gameTime;
+		// Visual feedback for difficulty increase
+		LK.effects.flashScreen(0xffaa00, 1000);
+	}
+	// Update spawn rate based on wave and difficulty
+	var difficultyMod = getDifficultyMultiplier();
+	var baseSpawnRate = Math.max(90 - waveNumber * 8, 20);
+	var adjustedSpawnRate = Math.max(15, Math.floor(baseSpawnRate / difficultyMod));
+	if (gameTime % adjustedSpawnRate === 0) {
 		spawnZombie();
 	}
+	// Spawn additional zombies in later difficulty levels
+	if (difficultyLevel >= 3 && gameTime % (adjustedSpawnRate * 2) === 0) {
+		spawnZombie();
+	}
+	if (difficultyLevel >= 5 && gameTime % (adjustedSpawnRate * 3) === 0) {
+		spawnZombie();
+	}
 	// Adjust drop rates based on game state
 	powerUpManager.adjustDropRates();
 	// Spawn wave-based power-ups occasionally
 	powerUpTimer++;