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

/**** 
* Classes
****/ 
var Dragon = Container.expand(function () {
	var self = Container.call(this);
	var dragonGraphics = self.attachAsset('dragon', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.health = 100;
	self.fireRate = 10;
	self.fireTimer = 0;
	self.speed = 8;
	self.update = function () {
		if (self.fireTimer > 0) {
			self.fireTimer--;
		}
	};
	self.canShoot = function () {
		return self.fireTimer <= 0;
	};
	self.shoot = function () {
		if (self.canShoot()) {
			var fireball = new Fireball();
			fireball.x = self.x + 60;
			fireball.y = self.y;
			fireballs.push(fireball);
			game.addChild(fireball);
			self.fireTimer = self.fireRate;
			LK.getSound('shoot').play();
		}
	};
	return self;
});
var Enemy = Container.expand(function () {
	var self = Container.call(this);
	var enemyGraphics = self.attachAsset('enemy1', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.health = 10;
	self.speed = 3;
	self.damage = 10;
	self.update = function () {
		self.x -= self.speed;
	};
	self.takeDamage = function (damage) {
		self.health -= damage;
		LK.effects.flashObject(self, 0xff0000, 200);
		if (self.health <= 0) {
			self.destroy();
			return true;
		}
		return false;
	};
	return self;
});
var EnemyProjectile = Container.expand(function () {
	var self = Container.call(this);
	var projectileGraphics = self.attachAsset('enemyProjectile', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.speed = 6;
	self.damage = 10;
	self.directionX = -1;
	self.directionY = 0;
	self.update = function () {
		self.x += self.speed * self.directionX;
		self.y += self.speed * self.directionY;
	};
	return self;
});
var Explosion = Container.expand(function () {
	var self = Container.call(this);
	var explosionGraphics = self.attachAsset('explosion', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.lifespan = 30;
	self.maxLifespan = 30;
	self.update = function () {
		self.lifespan--;
		var progress = 1 - self.lifespan / self.maxLifespan;
		// Scale up then down
		if (progress < 0.3) {
			explosionGraphics.scaleX = explosionGraphics.scaleY = progress * 6;
		} else {
			explosionGraphics.scaleX = explosionGraphics.scaleY = (1 - progress) * 2;
		}
		// Fade out
		explosionGraphics.alpha = 1 - progress;
		// Remove when done
		if (self.lifespan <= 0) {
			self.destroy();
			for (var i = explosions.length - 1; i >= 0; i--) {
				if (explosions[i] === self) {
					explosions.splice(i, 1);
					break;
				}
			}
		}
	};
	return self;
});
var FastEnemy = Container.expand(function () {
	var self = Container.call(this);
	var enemyGraphics = self.attachAsset('enemy2', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.health = 15;
	self.speed = 5;
	self.damage = 15;
	self.update = function () {
		self.x -= self.speed;
		self.y += Math.sin(self.x * 0.02) * 2;
	};
	self.takeDamage = function (damage) {
		self.health -= damage;
		LK.effects.flashObject(self, 0xff0000, 200);
		if (self.health <= 0) {
			self.destroy();
			return true;
		}
		return false;
	};
	return self;
});
var Fireball = Container.expand(function () {
	var self = Container.call(this);
	var fireballGraphics = self.attachAsset('fireball', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.speed = 12;
	self.damage = 10;
	self.update = function () {
		self.x += self.speed;
	};
	return self;
});
var PowerUp = Container.expand(function () {
	var self = Container.call(this);
	var powerUpGraphics = self.attachAsset('powerup', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.speed = 2;
	self.type = 'damage'; // damage, firerate, speed
	self.update = function () {
		self.x -= self.speed;
		self.rotation += 0.1;
	};
	return self;
});
var ShootingEnemy = Container.expand(function () {
	var self = Container.call(this);
	var enemyGraphics = self.attachAsset('enemy2', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.health = 20;
	self.speed = 2;
	self.damage = 20;
	self.fireRate = 60;
	self.fireTimer = 0;
	self.update = function () {
		self.x -= self.speed;
		if (self.fireTimer > 0) {
			self.fireTimer--;
		}
		// Shoot at dragon if in range
		if (self.x < 1800 && self.canShoot()) {
			self.shootAt(dragon.x, dragon.y);
		}
	};
	self.canShoot = function () {
		return self.fireTimer <= 0;
	};
	self.shootAt = function (targetX, targetY) {
		if (self.canShoot()) {
			var projectile = new EnemyProjectile();
			projectile.x = self.x - 30;
			projectile.y = self.y;
			var deltaX = targetX - projectile.x;
			var deltaY = targetY - projectile.y;
			var distance = Math.sqrt(deltaX * deltaX + deltaY * deltaY);
			if (distance > 0) {
				projectile.directionX = deltaX / distance;
				projectile.directionY = deltaY / distance;
			}
			enemyProjectiles.push(projectile);
			game.addChild(projectile);
			self.fireTimer = self.fireRate;
			LK.getSound('shoot').play();
		}
	};
	self.takeDamage = function (damage) {
		self.health -= damage;
		LK.effects.flashObject(self, 0xff0000, 200);
		if (self.health <= 0) {
			self.destroy();
			return true;
		}
		return false;
	};
	return self;
});
var Tower = Container.expand(function () {
	var self = Container.call(this);
	var towerGraphics = self.attachAsset('tower', {
		anchorX: 0.5,
		anchorY: 1.0
	});
	self.health = 200;
	self.fireRate = 45;
	self.fireTimer = 0;
	self.range = 400;
	self.update = function () {
		if (self.fireTimer > 0) {
			self.fireTimer--;
		}
		// Always shoot diagonally up-right continuously
		if (self.canShoot()) {
			self.shootAt(0, 0); // Parameters don't matter since we always shoot diagonally
		}
	};
	self.canShoot = function () {
		return self.fireTimer <= 0;
	};
	self.shootAt = function (targetX, targetY) {
		if (self.canShoot()) {
			var projectile = new TowerProjectile();
			projectile.x = self.x;
			projectile.y = self.y - 100;
			// Always shoot diagonally up-right instead of at target
			projectile.directionX = 0.7;
			projectile.directionY = -0.7;
			towerProjectiles.push(projectile);
			game.addChild(projectile);
			self.fireTimer = self.fireRate;
			LK.getSound('towerShoot').play();
		}
	};
	self.takeDamage = function (damage) {
		self.health -= damage;
		LK.effects.flashObject(self, 0xff0000, 200);
		if (self.health <= 0) {
			self.destroy();
			return true;
		}
		return false;
	};
	return self;
});
var TowerFragment = Container.expand(function () {
	var self = Container.call(this);
	var fragmentGraphics = self.attachAsset('towerFragment', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.speed = 8;
	self.damage = 8;
	self.directionX = 1;
	self.directionY = 0;
	self.lifespan = 60; // 1 second at 60fps
	self.update = function () {
		self.x += self.speed * self.directionX;
		self.y += self.speed * self.directionY;
		self.lifespan--;
		if (self.lifespan <= 0) {
			self.destroy();
		}
	};
	return self;
});
var TowerProjectile = Container.expand(function () {
	var self = Container.call(this);
	var projectileGraphics = self.attachAsset('towerProjectile', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.speed = 8;
	self.damage = 15;
	self.directionX = 0.7; // Diagonal right
	self.directionY = -0.7; // Diagonal up
	self.travelDistance = 0;
	self.explodeDistance = 800; // Distance before exploding - extended range
	self.hasExploded = false;
	self.update = function () {
		if (!self.hasExploded) {
			self.x += self.speed * self.directionX;
			self.y += self.speed * self.directionY;
			self.travelDistance += self.speed;
			// Explode after traveling set distance
			if (self.travelDistance >= self.explodeDistance) {
				self.explode();
			}
		}
	};
	self.explode = function () {
		if (self.hasExploded) return;
		self.hasExploded = true;
		// Create explosion effect
		createExplosion(self.x, self.y);
		// Create fragments in all directions
		var fragmentCount = 8;
		for (var i = 0; i < fragmentCount; i++) {
			var angle = i / fragmentCount * Math.PI * 2;
			var fragment = new TowerFragment();
			fragment.x = self.x;
			fragment.y = self.y;
			fragment.directionX = Math.cos(angle);
			fragment.directionY = Math.sin(angle);
			towerFragments.push(fragment);
			game.addChild(fragment);
		}
		// Remove this projectile
		self.destroy();
		for (var j = towerProjectiles.length - 1; j >= 0; j--) {
			if (towerProjectiles[j] === self) {
				towerProjectiles.splice(j, 1);
				break;
			}
		}
	};
	return self;
});

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

/**** 
* Game Code
****/ 
// Background
var forestBg = game.addChild(LK.getAsset('forestBg', {
	anchorX: 0,
	anchorY: 0,
	x: 0,
	y: 0,
	alpha: 0.7
}));
// Game variables
var dragon = game.addChild(new Dragon());
var fireballs = [];
var enemies = [];
var powerups = [];
var explosions = [];
var enemyProjectiles = [];
var towerProjectiles = [];
var towerFragments = [];
var enemySpawnTimer = 0;
var powerUpSpawnTimer = 0;
var waveLevel = 1;
var gameSpeed = 1;
var survivalTime = 0;
var enemiesKilled = 0;
// Add tower
var tower = game.addChild(new Tower());
tower.x = 200;
tower.y = 2500;
// Position initial elements
dragon.x = 1024;
dragon.y = 1366;
// UI Elements
var scoreTxt = new Text2('Score: 0', {
	size: 60,
	fill: 0xFFFFFF
});
scoreTxt.anchor.set(0, 0);
scoreTxt.x = 150;
scoreTxt.y = 50;
LK.gui.topLeft.addChild(scoreTxt);
var timeTxt = new Text2('Time: 0s', {
	size: 60,
	fill: 0xFFFFFF
});
timeTxt.anchor.set(0.5, 0);
LK.gui.top.addChild(timeTxt);
var waveTxt = new Text2('Wave: 1', {
	size: 50,
	fill: 0xFFFFFF
});
waveTxt.anchor.set(1, 0);
LK.gui.topRight.addChild(waveTxt);
function updateTime() {
	timeTxt.setText('Time: ' + Math.floor(survivalTime / 60) + 's');
}
function updateScore() {
	scoreTxt.setText('Score: ' + LK.getScore());
}
function updateWave() {
	waveTxt.setText('Wave: ' + waveLevel);
}
// Touch controls
var isDragging = false;
game.down = function (x, y, obj) {
	isDragging = true;
	dragon.shoot();
	// Immediate visual feedback for better control feel
	LK.effects.flashObject(dragon, 0x00ff00, 200);
	// Move dragon immediately to touch position for instant response
	var targetX = Math.max(100, Math.min(1900, x));
	var targetY = Math.max(100, Math.min(2600, y));
	dragon.x = targetX;
	dragon.y = targetY;
};
game.move = function (x, y, obj) {
	if (isDragging) {
		var targetX = Math.max(100, Math.min(1900, x));
		var targetY = Math.max(100, Math.min(2600, y));
		// Direct movement with smooth interpolation for responsive control
		var deltaX = targetX - dragon.x;
		var deltaY = targetY - dragon.y;
		var distance = Math.sqrt(deltaX * deltaX + deltaY * deltaY);
		var moveSpeed = 15; // Increased speed for better responsiveness
		// Move directly towards target with speed limit for smooth movement
		if (distance > 5) {
			// Only move if not very close to target
			dragon.x += deltaX / distance * Math.min(moveSpeed, distance);
			dragon.y += deltaY / distance * Math.min(moveSpeed, distance);
		} else {
			// Snap to target if very close
			dragon.x = targetX;
			dragon.y = targetY;
		}
	}
};
game.up = function (x, y, obj) {
	isDragging = false;
};
// Spawn functions
function spawnEnemy() {
	var enemy;
	var rand = Math.random();
	if (rand < 0.2 + waveLevel * 0.05) {
		enemy = new ShootingEnemy();
	} else if (rand < 0.4 + waveLevel * 0.1) {
		enemy = new FastEnemy();
	} else {
		enemy = new Enemy();
	}
	enemy.x = 2100;
	enemy.y = Math.random() * 2200 + 300;
	enemies.push(enemy);
	game.addChild(enemy);
}
function spawnPowerUp() {
	var powerup = new PowerUp();
	powerup.x = 2100;
	powerup.y = Math.random() * 2200 + 300;
	var rand = Math.random();
	if (rand < 0.4) {
		powerup.type = 'damage';
	} else if (rand < 0.7) {
		powerup.type = 'firerate';
	} else {
		powerup.type = 'speed';
	}
	powerups.push(powerup);
	game.addChild(powerup);
}
function createExplosion(x, y) {
	var explosion = new Explosion();
	explosion.x = x;
	explosion.y = y;
	explosions.push(explosion);
	game.addChild(explosion);
	LK.getSound('explosion').play();
	// Create additional tween effects for more dramatic explosion
	var particles = [];
	for (var i = 0; i < 5; i++) {
		var particle = LK.getAsset('explosion', {
			anchorX: 0.5,
			anchorY: 0.5,
			scaleX: 0.3,
			scaleY: 0.3
		});
		particle.x = x;
		particle.y = y;
		game.addChild(particle);
		particles.push(particle);
		var randomX = x + (Math.random() - 0.5) * 200;
		var randomY = y + (Math.random() - 0.5) * 200;
		tween(particle, {
			x: randomX,
			y: randomY,
			alpha: 0,
			scaleX: 0.1,
			scaleY: 0.1
		}, {
			duration: 800,
			easing: tween.easeOut,
			onFinish: function onFinish() {
				particle.destroy();
			}
		});
	}
}
// Main game loop
game.update = function () {
	// Update survival time
	survivalTime++;
	if (LK.ticks % 60 == 0) {
		updateTime();
	}
	// Increase difficulty over time
	if (LK.ticks % 1800 == 0) {
		// Every 30 seconds
		waveLevel++;
		updateWave();
		gameSpeed += 0.1;
	}
	// Spawn enemies
	enemySpawnTimer--;
	if (enemySpawnTimer <= 0) {
		spawnEnemy();
		enemySpawnTimer = Math.max(180 - waveLevel * 5, 60);
	}
	// Spawn power-ups occasionally
	powerUpSpawnTimer--;
	if (powerUpSpawnTimer <= 0) {
		if (Math.random() < 0.3) {
			spawnPowerUp();
		}
		powerUpSpawnTimer = Math.random() * 600 + 300; // 5-15 seconds
	}
	// Update fireballs
	for (var i = fireballs.length - 1; i >= 0; i--) {
		var fireball = fireballs[i];
		// Remove if off screen
		if (fireball.x > 2200) {
			fireball.destroy();
			fireballs.splice(i, 1);
			continue;
		}
		// Check collision with enemy projectiles
		for (var k = enemyProjectiles.length - 1; k >= 0; k--) {
			var enemyProjectile = enemyProjectiles[k];
			if (fireball.intersects(enemyProjectile)) {
				// Destroy both projectiles
				fireball.destroy();
				fireballs.splice(i, 1);
				enemyProjectile.destroy();
				enemyProjectiles.splice(k, 1);
				// Add small score bonus for defensive play
				LK.setScore(LK.getScore() + 5);
				updateScore();
				LK.getSound('enemyHit').play();
				// Create small explosion effect
				createExplosion(fireball.x, fireball.y);
				break;
			}
		}
		// Skip enemy collision check if fireball was already destroyed
		if (i >= fireballs.length) continue;
		// Check collision with enemies
		for (var j = enemies.length - 1; j >= 0; j--) {
			var enemy = enemies[j];
			if (fireball.intersects(enemy)) {
				if (enemy.takeDamage(fireball.damage)) {
					createExplosion(enemy.x, enemy.y);
					enemies.splice(j, 1);
					enemiesKilled++;
					LK.setScore(LK.getScore() + 10);
					updateScore();
					LK.getSound('enemyHit').play();
				}
				fireball.destroy();
				fireballs.splice(i, 1);
				break;
			}
		}
	}
	// Update enemies
	for (var i = enemies.length - 1; i >= 0; i--) {
		var enemy = enemies[i];
		// Remove enemies that go off screen (left side)
		if (enemy.x < -100) {
			enemy.destroy();
			enemies.splice(i, 1);
			continue;
		}
		// Check collision with dragon - game over if hit
		if (enemy.intersects(dragon)) {
			LK.effects.flashScreen(0xff0000, 1000);
			LK.showGameOver();
		}
	}
	// Update power-ups
	for (var i = powerups.length - 1; i >= 0; i--) {
		var powerup = powerups[i];
		// Remove if off screen
		if (powerup.x < -100) {
			powerup.destroy();
			powerups.splice(i, 1);
			continue;
		}
		// Check collision with dragon
		if (powerup.intersects(dragon)) {
			if (powerup.type === 'damage') {
				dragon.damage = Math.min(dragon.damage + 5, 50);
			} else if (powerup.type === 'firerate') {
				dragon.fireRate = Math.max(dragon.fireRate - 2, 3);
			} else if (powerup.type === 'speed') {
				dragon.speed = Math.min(dragon.speed + 1, 15);
			}
			LK.getSound('powerUpCollect').play();
			LK.effects.flashObject(dragon, 0xffd700, 500);
			powerup.destroy();
			powerups.splice(i, 1);
		}
	}
	// Update enemy projectiles
	for (var i = enemyProjectiles.length - 1; i >= 0; i--) {
		var projectile = enemyProjectiles[i];
		// Remove if off screen
		if (projectile.x < -100 || projectile.x > 2200 || projectile.y < -100 || projectile.y > 2800) {
			projectile.destroy();
			enemyProjectiles.splice(i, 1);
			continue;
		}
		// Check collision with dragon - game over if hit
		if (projectile.intersects(dragon)) {
			LK.effects.flashScreen(0xff0000, 1000);
			LK.showGameOver();
		}
	}
	// Update tower projectiles
	for (var i = towerProjectiles.length - 1; i >= 0; i--) {
		var projectile = towerProjectiles[i];
		// Remove if off screen (they should explode before this)
		if (projectile.x > 2200 || projectile.x < -100 || projectile.y > 2800 || projectile.y < -100) {
			projectile.destroy();
			towerProjectiles.splice(i, 1);
			continue;
		}
	}
	// Update tower fragments
	for (var i = towerFragments.length - 1; i >= 0; i--) {
		var fragment = towerFragments[i];
		// Remove if off screen or lifespan expired
		if (fragment.x > 2200 || fragment.x < -100 || fragment.y > 2800 || fragment.y < -100 || fragment.lifespan <= 0) {
			fragment.destroy();
			towerFragments.splice(i, 1);
			continue;
		}
		// Check collision with enemies
		for (var j = enemies.length - 1; j >= 0; j--) {
			var enemy = enemies[j];
			if (fragment.intersects(enemy)) {
				if (enemy.takeDamage(fragment.damage)) {
					createExplosion(enemy.x, enemy.y);
					enemies.splice(j, 1);
					enemiesKilled++;
					LK.setScore(LK.getScore() + 10);
					updateScore();
					LK.getSound('enemyHit').play();
				}
				fragment.destroy();
				towerFragments.splice(i, 1);
				break;
			}
		}
	}
	// Check if enemies hit the tower
	for (var i = enemies.length - 1; i >= 0; i--) {
		var enemy = enemies[i];
		if (enemy.intersects(tower)) {
			if (tower.takeDamage(enemy.damage)) {
				// Tower destroyed - game over
				LK.effects.flashScreen(0xff0000, 1000);
				LK.showGameOver();
			}
			enemy.destroy();
			enemies.splice(i, 1);
		}
	}
	// Auto-shoot for dragon
	if (LK.ticks % 20 == 0) {
		dragon.shoot();
	}
	// Smooth movement dampening when not actively dragging
	if (!isDragging) {
		// Apply slight dampening to make movement feel more natural
		dragon.x += (dragon.x - dragon.x) * 0.1;
		dragon.y += (dragon.y - dragon.y) * 0.1;
	}
};
// Start background music
LK.playMusic('bgmusic');

===================================================================
--- original.js
+++ change.js
@@ -407,26 +407,35 @@
 var isDragging = false;
 game.down = function (x, y, obj) {
 	isDragging = true;
 	dragon.shoot();
+	// Immediate visual feedback for better control feel
+	LK.effects.flashObject(dragon, 0x00ff00, 200);
+	// Move dragon immediately to touch position for instant response
+	var targetX = Math.max(100, Math.min(1900, x));
+	var targetY = Math.max(100, Math.min(2600, y));
+	dragon.x = targetX;
+	dragon.y = targetY;
 };
 game.move = function (x, y, obj) {
 	if (isDragging) {
 		var targetX = Math.max(100, Math.min(1900, x));
 		var targetY = Math.max(100, Math.min(2600, y));
-		// Stop any existing movement tweens
-		tween.stop(dragon, {
-			x: true,
-			y: true
-		});
-		// Create smooth movement tween with faster response time
-		tween(dragon, {
-			x: targetX,
-			y: targetY
-		}, {
-			duration: 100,
-			easing: tween.easeOut
-		});
+		// Direct movement with smooth interpolation for responsive control
+		var deltaX = targetX - dragon.x;
+		var deltaY = targetY - dragon.y;
+		var distance = Math.sqrt(deltaX * deltaX + deltaY * deltaY);
+		var moveSpeed = 15; // Increased speed for better responsiveness
+		// Move directly towards target with speed limit for smooth movement
+		if (distance > 5) {
+			// Only move if not very close to target
+			dragon.x += deltaX / distance * Math.min(moveSpeed, distance);
+			dragon.y += deltaY / distance * Math.min(moveSpeed, distance);
+		} else {
+			// Snap to target if very close
+			dragon.x = targetX;
+			dragon.y = targetY;
+		}
 	}
 };
 game.up = function (x, y, obj) {
 	isDragging = false;
@@ -681,7 +690,13 @@
 	// Auto-shoot for dragon
 	if (LK.ticks % 20 == 0) {
 		dragon.shoot();
 	}
+	// Smooth movement dampening when not actively dragging
+	if (!isDragging) {
+		// Apply slight dampening to make movement feel more natural
+		dragon.x += (dragon.x - dragon.x) * 0.1;
+		dragon.y += (dragon.y - dragon.y) * 0.1;
+	}
 };
 // Start background music
 LK.playMusic('bgmusic');
\ No newline at end of file